@donkeylabs/cli 2.0.20 → 2.0.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donkeylabs/cli",
-  "version": "2.0.20",
+  "version": "2.0.22",
   "type": "module",
   "description": "CLI for @donkeylabs/server - project scaffolding and code generation",
   "main": "./src/index.ts",
@@ -30,6 +30,7 @@
     "picocolors": "^1.1.1",
     "prompts": "^2.4.2",
     "sharp": "^0.33.0",
+    "typescript": "^5.0.0",
     "zod": "^3.23.0"
   },
   "devDependencies": {

package/src/commands/generate.ts

@@ -7,6 +7,7 @@ import { Kysely, Migrator, FileMigrationProvider } from "kysely";
 import { BunSqliteDialect } from "kysely-bun-sqlite";
 import { Database } from "bun:sqlite";
 import { generate, KyselyBunSqliteDialect } from "kysely-codegen";
+import * as ts from "typescript";
 
 interface DonkeylabsConfig {
   plugins: string[];
@@ -69,20 +70,272 @@ async function extractHandlerNames(pluginPath: string): Promise<string[]> {
 async function extractMiddlewareNames(pluginPath: string): Promise<string[]> {
   try {
     const content = await readFile(pluginPath, "utf-8");
+    const astNames = extractMiddlewareNamesFromAst(content, pluginPath);
+    if (astNames.length > 0) {
+      return astNames;
+    }
 
-    // Look for middleware definitions: `name: createMiddleware(...)`
-    // This works for both old `middleware: { timing: createMiddleware(...) }`
-    // and new `middleware: (ctx) => ({ timing: createMiddleware(...) })`
-    const middlewareNames = [...content.matchAll(/(\w+)\s*:\s*createMiddleware\s*\(/g)]
-      .map((m) => m[1])
-      .filter((name): name is string => !!name);
-
-    return middlewareNames;
+    return extractMiddlewareNamesRegexFallback(content);
   } catch {
     return [];
   }
 }
 
+function extractMiddlewareNamesFromAst(content: string, fileName: string): string[] {
+  const sourceFile = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+
+  const names = new Set<string>();
+
+  const addFromObjectLiteral = (obj: ts.ObjectLiteralExpression) => {
+    for (const prop of obj.properties) {
+      if (!ts.isPropertyAssignment(prop) && !ts.isMethodDeclaration(prop)) continue;
+      const propName = getStaticPropertyName(prop.name);
+      if (propName && isSafeIdentifier(propName)) {
+        names.add(propName);
+      }
+    }
+  };
+
+  const collectFromMiddlewareInitializer = (initializer: ts.Expression) => {
+    if (ts.isObjectLiteralExpression(initializer)) {
+      addFromObjectLiteral(initializer);
+      return;
+    }
+
+    if (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) {
+      const body = initializer.body;
+
+      if (ts.isObjectLiteralExpression(body)) {
+        addFromObjectLiteral(body);
+        return;
+      }
+
+      if (ts.isParenthesizedExpression(body) && ts.isObjectLiteralExpression(body.expression)) {
+        addFromObjectLiteral(body.expression);
+        return;
+      }
+
+      if (ts.isBlock(body)) {
+        for (const stmt of body.statements) {
+          if (!ts.isReturnStatement(stmt) || !stmt.expression) continue;
+
+          if (ts.isObjectLiteralExpression(stmt.expression)) {
+            addFromObjectLiteral(stmt.expression);
+            return;
+          }
+
+          if (
+            ts.isParenthesizedExpression(stmt.expression) &&
+            ts.isObjectLiteralExpression(stmt.expression.expression)
+          ) {
+            addFromObjectLiteral(stmt.expression.expression);
+            return;
+          }
+        }
+      }
+    }
+  };
+
+  const visit = (node: ts.Node) => {
+    if (ts.isPropertyAssignment(node)) {
+      const propName = getStaticPropertyName(node.name);
+      if (propName === "middleware") {
+        collectFromMiddlewareInitializer(node.initializer);
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+
+  visit(sourceFile);
+  return [...names];
+}
+
+function getStaticPropertyName(name: ts.PropertyName): string | null {
+  if (ts.isIdentifier(name)) return name.text;
+  if (ts.isStringLiteral(name)) return name.text;
+  if (ts.isNoSubstitutionTemplateLiteral(name)) return name.text;
+  if (ts.isNumericLiteral(name)) return name.text;
+  return null;
+}
+
+function isSafeIdentifier(name: string): boolean {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+}
+
+function extractMiddlewareNamesRegexFallback(content: string): string[] {
+  const names = new Set<string>();
+
+  // Look for middleware definitions: `name: createMiddleware(...)`
+  // Supports generic config: `name: createMiddleware<Config>(...)`
+  for (const match of content.matchAll(/(\w+)\s*:\s*createMiddleware\s*(?:<[^>]+>)?\s*\(/g)) {
+    if (match[1]) names.add(match[1]);
+  }
+
+  // Look for direct middleware objects: `middleware: { ... }`
+  for (const match of content.matchAll(/middleware\s*:\s*\{/g)) {
+    const openBracePos = (match.index ?? 0) + match[0].length - 1;
+    const block = extractBalancedBlock(content, openBracePos, "{", "}");
+    for (const key of extractTopLevelObjectKeys(block)) {
+      names.add(key);
+    }
+  }
+
+  // Look for middleware factory returning object literal directly:
+  // `middleware: (ctx, service) => ({ ... })`
+  for (const match of content.matchAll(/middleware\s*:\s*\([^)]*\)\s*=>\s*\(\s*\{/g)) {
+    const openBracePos = (match.index ?? 0) + match[0].length - 1;
+    const block = extractBalancedBlock(content, openBracePos, "{", "}");
+    for (const key of extractTopLevelObjectKeys(block)) {
+      names.add(key);
+    }
+  }
+
+  // Look for middleware factory with block body:
+  // `middleware: (...) => { return { ... } }`
+  for (const match of content.matchAll(/middleware\s*:\s*\([^)]*\)\s*=>\s*\{/g)) {
+    const openBracePos = (match.index ?? 0) + match[0].length - 1;
+    const fnBody = extractBalancedBlock(content, openBracePos, "{", "}");
+    if (!fnBody) continue;
+
+    const returnMatch = fnBody.match(/return\s*\{/);
+    if (!returnMatch || returnMatch.index === undefined) continue;
+
+    const returnObjStart = returnMatch.index + returnMatch[0].length - 1;
+    const returnObj = extractBalancedBlock(fnBody, returnObjStart, "{", "}");
+    for (const key of extractTopLevelObjectKeys(returnObj)) {
+      names.add(key);
+    }
+  }
+
+  return [...names];
+}
+
+function extractTopLevelObjectKeys(objectBlock: string): string[] {
+  if (!objectBlock || !objectBlock.startsWith("{") || !objectBlock.endsWith("}")) {
+    return [];
+  }
+
+  const keys: string[] = [];
+  const src = objectBlock.slice(1, -1);
+  const len = src.length;
+
+  let i = 0;
+  let braceDepth = 0;
+  let bracketDepth = 0;
+  let parenDepth = 0;
+
+  const isIdentifierStart = (ch: string) => /[A-Za-z_$]/.test(ch);
+  const isIdentifierPart = (ch: string) => /[A-Za-z0-9_$]/.test(ch);
+
+  while (i < len) {
+    const ch = src[i]!;
+
+    // Skip strings
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const quote = ch;
+      i++;
+      while (i < len) {
+        const c = src[i]!;
+        if (c === "\\") {
+          i += 2;
+          continue;
+        }
+        if (c === quote) {
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+
+    // Skip comments
+    if (ch === "/" && src[i + 1] === "/") {
+      i += 2;
+      while (i < len && src[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "/" && src[i + 1] === "*") {
+      i += 2;
+      while (i + 1 < len && !(src[i] === "*" && src[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+
+    // Track nesting
+    if (ch === "{") {
+      braceDepth++;
+      i++;
+      continue;
+    }
+    if (ch === "}") {
+      braceDepth = Math.max(0, braceDepth - 1);
+      i++;
+      continue;
+    }
+    if (ch === "[") {
+      bracketDepth++;
+      i++;
+      continue;
+    }
+    if (ch === "]") {
+      bracketDepth = Math.max(0, bracketDepth - 1);
+      i++;
+      continue;
+    }
+    if (ch === "(") {
+      parenDepth++;
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      parenDepth = Math.max(0, parenDepth - 1);
+      i++;
+      continue;
+    }
+
+    // Parse top-level keys only
+    if (braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) {
+      // Skip whitespace and commas
+      if (/\s|,/.test(ch)) {
+        i++;
+        continue;
+      }
+
+      let key = "";
+      const keyStart = i;
+
+      // Identifier key: authRequired: ... or authRequired(...) { ... }
+      if (isIdentifierStart(ch)) {
+        i++;
+        while (i < len && isIdentifierPart(src[i]!)) i++;
+        key = src.slice(keyStart, i);
+      } else {
+        i++;
+        continue;
+      }
+
+      // Skip optional marker and whitespace
+      while (i < len && /\s/.test(src[i]!)) i++;
+      if (src[i] === "?") {
+        i++;
+        while (i < len && /\s/.test(src[i]!)) i++;
+      }
+
+      // Object property or method shorthand
+      if (src[i] === ":" || src[i] === "(") {
+        keys.push(key);
+      }
+
+      continue;
+    }
+
+    i++;
+  }
+
+  return keys;
+}
+
 interface ServiceDefinitionInfo {
   name: string;
   exportName: string;
@@ -1270,4 +1523,3 @@ ${eventRegistryEntries.join("\n")}
 
   await writeFile(join(outPath, "events.ts"), content);
 }
-