@donkeylabs/cli 2.0.19 → 2.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donkeylabs/cli",
-  "version": "2.0.19",
+  "version": "2.0.21",
   "type": "module",
   "description": "CLI for @donkeylabs/server - project scaffolding and code generation",
   "main": "./src/index.ts",

package/src/commands/generate.ts

@@ -70,19 +70,182 @@ async function extractMiddlewareNames(pluginPath: string): Promise<string[]> {
   try {
     const content = await readFile(pluginPath, "utf-8");
 
+    const names = new Set<string>();
+
     // 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);
+    // 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;
 
-    return middlewareNames;
+      const returnObjStart = returnMatch.index + returnMatch[0].length - 1;
+      const returnObj = extractBalancedBlock(fnBody, returnObjStart, "{", "}");
+      for (const key of extractTopLevelObjectKeys(returnObj)) {
+        names.add(key);
+      }
+    }
+
+    return [...names];
   } catch {
     return [];
   }
 }
 
+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 +1433,3 @@ ${eventRegistryEntries.join("\n")}
 
   await writeFile(join(outPath, "events.ts"), content);
 }
-

package/templates/starter/donkeylabs.config.ts

@@ -0,0 +1 @@
+export default {};

package/templates/starter/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "donkeylabs-starter",
+  "type": "module",
+  "dependencies": {
+    "@donkeylabs/server": "workspace:*"
+  }
+}

package/templates/starter/src/index.ts

@@ -0,0 +1,9 @@
+import { AppServer } from "@donkeylabs/server";
+
+const server = new AppServer({
+  db: undefined as any,
+});
+
+server.start().catch((err) => {
+  console.error("Failed to start server", err);
+});

package/templates/starter/src/routes/health/handlers/ping.ts

@@ -0,0 +1,35 @@
+import type { ServerContext } from "@donkeylabs/server";
+
+type AppContext = ServerContext;
+
+interface Handler<TInput = any, TOutput = any> {
+  handle(input: TInput): TOutput | Promise<TOutput>;
+}
+
+type PingInput = {
+  name: string;
+  cool: number;
+  echo?: string;
+};
+
+type PingOutput = {
+  status: "ok";
+  timestamp: string;
+  echo?: string;
+};
+
+export class PingHandler implements Handler {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  async handle(input: PingInput): Promise<PingOutput> {
+    return {
+      status: "ok",
+      timestamp: new Date().toISOString(),
+      echo: input.echo,
+    };
+  }
+}

package/templates/sveltekit-app/src/server/routes/counter/handlers/decrement.ts

@@ -0,0 +1,19 @@
+import type { ServerContext } from "@donkeylabs/server";
+
+type AppContext = ServerContext;
+
+interface Handler<TInput = any, TOutput = any> {
+  handle(input: TInput): TOutput | Promise<TOutput>;
+}
+
+export class CounterDecrementHandler implements Handler {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  async handle(): Promise<{ count: number }> {
+    return { count: -1 };
+  }
+}

package/templates/sveltekit-app/src/server/routes/counter/handlers/get.ts

@@ -0,0 +1,19 @@
+import type { ServerContext } from "@donkeylabs/server";
+
+type AppContext = ServerContext;
+
+interface Handler<TInput = any, TOutput = any> {
+  handle(input: TInput): TOutput | Promise<TOutput>;
+}
+
+export class CounterGetHandler implements Handler {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  async handle(): Promise<{ count: number }> {
+    return { count: 0 };
+  }
+}

package/templates/sveltekit-app/src/server/routes/counter/handlers/increment.ts

@@ -0,0 +1,19 @@
+import type { ServerContext } from "@donkeylabs/server";
+
+type AppContext = ServerContext;
+
+interface Handler<TInput = any, TOutput = any> {
+  handle(input: TInput): TOutput | Promise<TOutput>;
+}
+
+export class CounterIncrementHandler implements Handler {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  async handle(): Promise<{ count: number }> {
+    return { count: 1 };
+  }
+}

package/templates/sveltekit-app/src/server/routes/counter/index.ts

@@ -0,0 +1,11 @@
+import { createRouter } from "@donkeylabs/server";
+import { CounterGetHandler } from "./handlers/get";
+import { CounterIncrementHandler } from "./handlers/increment";
+import { CounterDecrementHandler } from "./handlers/decrement";
+
+export const counterRouter = createRouter("counter")
+  .route("counter.get").typed({ handle: CounterGetHandler })
+  .route("counter.increment").typed({ handle: CounterIncrementHandler })
+  .route("counter.decrement").typed({ handle: CounterDecrementHandler });
+
+export default counterRouter;