website refactor

2026-01-13 02:38:49 +01:00
parent e981ebd9e9
commit 38b25bafe1
20 changed files with 1138 additions and 80 deletions
--- a/apps/website/eslint-rules/test-rule-with-logging.js
+++ b/apps/website/eslint-rules/test-rule-with-logging.js
@@ -0,0 +1,190 @@
+/**
+ * Test with logging inside the rule
+ */
+
+const rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Test',
+      category: 'Page Query',
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      mustUseBuilder: 'Must use builders',
+    },
+  },
+
+  create(context) {
+    let inPageQueryExecute = false;
+    let hasManualTransformation = false;
+    let hasBuilderCall = false;
+    let pageQueryClassName = null;
+
+    return {
+      ClassDeclaration(node) {
+        if (node.id && node.id.name && node.id.name.endsWith('PageQuery')) {
+          pageQueryClassName = node.id.name;
+          console.log('  [ClassDeclaration] Found:', pageQueryClassName);
+        }
+      },
+
+      MethodDefinition(node) {
+        if (node.key.type === 'Identifier' &&
+            node.key.name === 'execute' &&
+            node.parent.type === 'ClassBody') {
+          
+          const classNode = node.parent.parent;
+          if (classNode && classNode.id && classNode.id.name &&
+              classNode.id.name.endsWith('PageQuery')) {
+            inPageQueryExecute = true;
+            console.log('  [MethodDefinition] execute() in PageQuery');
+          }
+        }
+      },
+
+      CallExpression(node) {
+        if (inPageQueryExecute) {
+          console.log('  [CallExpression] inside execute:', node.callee.type);
+          if (node.callee.type === 'MemberExpression' &&
+              node.callee.property.type === 'Identifier' &&
+              (node.callee.property.name === 'build' || node.callee.property.name === 'createViewData')) {
+            console.log('  [CallExpression] Found Builder call!');
+            hasBuilderCall = true;
+          }
+        }
+      },
+
+      VariableDeclarator(node) {
+        if (inPageQueryExecute && node.init && node.init.type === 'ObjectExpression') {
+          console.log('  [VariableDeclarator] ObjectExpression found');
+          hasManualTransformation = true;
+        }
+      },
+
+      ReturnStatement(node) {
+        if (inPageQueryExecute && node.argument) {
+          console.log('  [ReturnStatement] type:', node.argument.type);
+          
+          // Direct object literal return
+          if (node.argument.type === 'ObjectExpression') {
+            console.log('  [ReturnStatement] ObjectExpression - setting manual transformation');
+            hasManualTransformation = true;
+          }
+          // Direct identifier return
+          else if (node.argument.type === 'Identifier') {
+            console.log('  [ReturnStatement] Identifier:', node.argument.name);
+            if (!node.argument.name.includes('ViewData') && !node.argument.name.includes('viewData')) {
+              console.log('  [ReturnStatement] Not ViewData, checking builder call...');
+              if (!hasBuilderCall) {
+                console.log('  [ReturnStatement] No builder call - setting manual transformation');
+                hasManualTransformation = true;
+              }
+            }
+          }
+          // CallExpression
+          else if (node.argument.type === 'CallExpression') {
+            console.log('  [ReturnStatement] CallExpression');
+            const callExpr = node.argument;
+            if (callExpr.callee.type === 'MemberExpression' &&
+                callExpr.callee.object.type === 'Identifier' &&
+                callExpr.callee.object.name === 'Result' &&
+                callExpr.callee.property.type === 'Identifier' &&
+                (callExpr.callee.property.name === 'ok' || callExpr.callee.property.name === 'err')) {
+              
+              console.log('  [ReturnStatement] Result.' + callExpr.callee.property.name + '()');
+              
+              if (callExpr.callee.property.name === 'ok' && 
+                  callExpr.arguments.length > 0 &&
+                  callExpr.arguments[0].type === 'Identifier') {
+                const argName = callExpr.arguments[0].name;
+                console.log('  [ReturnStatement] Argument:', argName);
+                
+                const isApiDto = argName.includes('Dto') || 
+                                 argName.includes('api') || 
+                                 argName === 'result' ||
+                                 argName === 'data';
+                
+                console.log('  [ReturnStatement] Is API DTO?', isApiDto);
+                console.log('  [ReturnStatement] Has builder call?', hasBuilderCall);
+                
+                if (isApiDto && !hasBuilderCall) {
+                  console.log('  [ReturnStatement] ✓ Setting manual transformation!');
+                  hasManualTransformation = true;
+                }
+              }
+            }
+          }
+        }
+      },
+
+      'MethodDefinition:exit'(node) {
+        if (node.key.type === 'Identifier' && node.key.name === 'execute') {
+          inPageQueryExecute = false;
+          console.log('  [MethodDefinition:exit] execute()');
+        }
+      },
+
+      'Program:exit'() {
+        console.log('\n[Program:exit]');
+        console.log('  hasManualTransformation:', hasManualTransformation);
+        console.log('  hasBuilderCall:', hasBuilderCall);
+        console.log('  Should report?', hasManualTransformation && !hasBuilderCall);
+        
+        if (hasManualTransformation && !hasBuilderCall) {
+          console.log('  ✓✓✓ REPORTING ERROR ✓✓✓');
+          context.report({
+            node: context.getSourceCode().ast,
+            messageId: 'mustUseBuilder',
+          });
+        }
+      },
+    };
+  },
+};
+
+// Test it
+const mockContext = {
+  getSourceCode: () => ({ ast: {} }),
+  report: (data) => {
+    console.log('\n*** REPORT CALLED ***');
+  }
+};
+
+const visitor = rule.create(mockContext);
+
+console.log('=== Test with Logging ===\n');
+
+visitor.ClassDeclaration({
+  id: { name: 'AdminDashboardPageQuery' }
+});
+
+visitor.MethodDefinition({
+  key: { type: 'Identifier', name: 'execute' },
+  parent: { type: 'ClassBody' }
+});
+
+visitor.VariableDeclarator({
+  init: { type: 'CallExpression' }
+});
+
+visitor.ReturnStatement({
+  argument: {
+    type: 'CallExpression',
+    callee: {
+      type: 'MemberExpression',
+      object: { type: 'Identifier', name: 'Result' },
+      property: { type: 'Identifier', name: 'ok' }
+    },
+    arguments: [{ type: 'Identifier', name: 'apiDto' }]
+  }
+});
+
+visitor['MethodDefinition:exit']({
+  key: { type: 'Identifier', name: 'execute' }
+});
+
+visitor['Program:exit']();
+
+console.log('\n=== Done ===');