@archlast/cli 0.0.1

package/dist/generator.js

@@ -0,0 +1,1816 @@
+import * as fs from "fs";
+import * as path from "path";
+import { join } from "path";
+import { Project, SyntaxKind } from "ts-morph";
+import { generateDI } from "./generators/di";
+// Helper to resolve imports
+function resolveImport(typeText, sourceFile) {
+    return typeText.replace(/import\("([^"]+)"\)\./g, (match, path) => {
+        if (path.includes("packages/server/src/db/sqlite")) {
+            return "Document";
+        }
+        return "";
+    });
+}
+export class TypeGenerator {
+    archlastPath;
+    constructor(archlastPath) {
+        this.archlastPath = path.resolve(archlastPath);
+    }
+    async generate(analysis) {
+        const srcPath = path.join(this.archlastPath, "src");
+        const generatedDir = path.join(this.archlastPath, "_generated");
+        // Ensure directory exists
+        if (!fs.existsSync(generatedDir)) {
+            fs.mkdirSync(generatedDir, { recursive: true });
+        }
+        // Generate types using ts-morph for sophisticated type inference
+        const typeInfos = await this.analyzeTypesWithTsMorph(srcPath);
+        const rpcTypeInfos = await this.analyzeRpcTypesWithTsMorph(srcPath);
+        const apiTypes = await this.generateApiTypes(typeInfos);
+        const serverTypes = await this.generateServerTypes();
+        const indexExport = this.generateIndexExport();
+        const rpcTypes = await this.generateRpcTypes(rpcTypeInfos);
+        const trpcRouter = await this.generateTrpcRouter(rpcTypeInfos);
+        const apiPath = path.join(generatedDir, "api.ts");
+        const serverPath = path.join(generatedDir, "server.ts");
+        const indexPath = path.join(generatedDir, "index.ts");
+        const rpcPath = path.join(generatedDir, "rpc.ts");
+        const trpcRouterPath = path.join(generatedDir, "trpc-router.ts");
+        fs.writeFileSync(apiPath, apiTypes, "utf-8");
+        fs.writeFileSync(serverPath, serverTypes, "utf-8");
+        fs.writeFileSync(indexPath, indexExport, "utf-8");
+        fs.writeFileSync(rpcPath, rpcTypes, "utf-8");
+        fs.writeFileSync(trpcRouterPath, trpcRouter, "utf-8");
+        // Generate CRUD handlers
+        await this.generateCrudHandlers(generatedDir);
+        // Generate DI registration code if there are injectables
+        if (analysis.injectables && analysis.injectables.length > 0) {
+            await generateDI(generatedDir, analysis.injectables);
+            console.log(`  Generated DI registration with ${analysis.injectables.length} providers`);
+        }
+        // Log RPC generation
+        if (rpcTypeInfos.length > 0) {
+            console.log(`  Generated ${rpcTypeInfos.length} RPC procedure types`);
+            console.log(`  Generated tRPC router with AppRouter type`);
+        }
+    }
+    async analyzeTypesWithTsMorph(srcPath) {
+        const project = new Project({
+            skipAddingFilesFromTsConfig: true,
+        });
+        project.addSourceFilesAtPaths(path.join(srcPath, "**/*.ts"));
+        const typeInfos = [];
+        const sourceFiles = project.getSourceFiles();
+        for (const sourceFile of sourceFiles) {
+            const fileName = sourceFile.getBaseName();
+            const moduleName = fileName.replace(/\.ts$/, "");
+            const exportedVariables = sourceFile
+                .getVariableDeclarations()
+                .filter((v) => v.isExported());
+            for (const variable of exportedVariables) {
+                const name = variable.getName();
+                const initializer = variable.getInitializer();
+                if (initializer && initializer.getKind() === SyntaxKind.CallExpression) {
+                    const callExpr = initializer.asKindOrThrow(SyntaxKind.CallExpression);
+                    const functionName = callExpr.getExpression().getText();
+                    if (functionName === "mutation" ||
+                        functionName === "query" ||
+                        functionName === "action") {
+                        const typeInfo = this.extractTypeInfo(callExpr, moduleName, name, functionName, sourceFile);
+                        if (typeInfo) {
+                            typeInfos.push(typeInfo);
+                        }
+                    }
+                }
+            }
+        }
+        return typeInfos;
+    }
+    async analyzeRpcTypesWithTsMorph(srcPath) {
+        const project = new Project({
+            skipAddingFilesFromTsConfig: true,
+        });
+        project.addSourceFilesAtPaths(path.join(srcPath, "**/*.ts"));
+        const typeInfos = [];
+        const sourceFiles = project.getSourceFiles();
+        for (const sourceFile of sourceFiles) {
+            const fileName = sourceFile.getBaseName();
+            const moduleName = fileName.replace(/\.ts$/, "");
+            const exportedVariables = sourceFile
+                .getVariableDeclarations()
+                .filter((v) => v.isExported());
+            for (const variable of exportedVariables) {
+                const name = variable.getName();
+                const initializer = variable.getInitializer();
+                if (initializer && initializer.getKind() === SyntaxKind.CallExpression) {
+                    const callExpr = initializer.asKindOrThrow(SyntaxKind.CallExpression);
+                    const callText = callExpr.getExpression().getText();
+                    // Check for rpc.query or rpc.mutation
+                    if (callText === "rpc.query" || callText === "rpc.mutation") {
+                        const typeInfo = this.extractRpcTypeInfo(callExpr, moduleName, name, callText === "rpc.query" ? "query" : "mutation", sourceFile);
+                        if (typeInfo) {
+                            typeInfos.push(typeInfo);
+                        }
+                    }
+                }
+            }
+        }
+        return typeInfos;
+    }
+    extractRpcTypeInfo(callExpr, moduleName, name, procedureType, sourceFile) {
+        const firstArg = callExpr.getArguments()[0];
+        let handlerFunc = null;
+        let authMode = undefined;
+        if (firstArg.getKind() === SyntaxKind.ObjectLiteralExpression) {
+            const obj = firstArg.asKind(SyntaxKind.ObjectLiteralExpression);
+            const handlerProp = obj?.getProperty("handler");
+            if (handlerProp && handlerProp.getKind() === SyntaxKind.PropertyAssignment) {
+                handlerFunc = handlerProp
+                    .asKind(SyntaxKind.PropertyAssignment)
+                    ?.getInitializer()
+                    ?.asKind(SyntaxKind.ArrowFunction);
+            }
+            // Extract auth mode
+            const authProp = obj?.getProperty("auth");
+            if (authProp && authProp.getKind() === SyntaxKind.PropertyAssignment) {
+                const authInit = authProp.asKind(SyntaxKind.PropertyAssignment)?.getInitializer();
+                if (authInit && authInit.getKind() === SyntaxKind.StringLiteral) {
+                    const authValue = authInit.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+                    if (authValue === "required" ||
+                        authValue === "optional" ||
+                        authValue === "public") {
+                        authMode = authValue;
+                    }
+                }
+            }
+        }
+        if (!handlerFunc)
+            return null;
+        let argsType = "Record<string, never>";
+        let hasArgs = false;
+        // Extract args from Zod schema
+        if (firstArg.getKind() === SyntaxKind.ObjectLiteralExpression) {
+            const obj = firstArg.asKind(SyntaxKind.ObjectLiteralExpression);
+            const argsProp = obj?.getProperty("args");
+            if (argsProp && argsProp.getKind() === SyntaxKind.PropertyAssignment) {
+                const argsInit = argsProp.asKind(SyntaxKind.PropertyAssignment)?.getInitializer();
+                if (argsInit) {
+                    // Handle both direct object literal { id: z.string() } and z.object({ id: z.string() })
+                    if (argsInit.getKind() === SyntaxKind.ObjectLiteralExpression) {
+                        argsType = this.parseZodSchema(argsInit);
+                        hasArgs = true;
+                    }
+                    else if (argsInit.getKind() === SyntaxKind.CallExpression) {
+                        // Check if it's z.object({ ... })
+                        const callText = argsInit.getText();
+                        if (callText.startsWith("z.object(") || callText.startsWith("v.object(")) {
+                            // Get the first argument of z.object() call
+                            const callExprArgs = argsInit.asKind(SyntaxKind.CallExpression)?.getArguments();
+                            if (callExprArgs && callExprArgs.length > 0) {
+                                const objectArg = callExprArgs[0];
+                                if (objectArg.getKind() === SyntaxKind.ObjectLiteralExpression) {
+                                    argsType = this.parseZodSchema(objectArg);
+                                    hasArgs = true;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Fallback to inferred args type
+        if (!hasArgs) {
+            const params = handlerFunc.getParameters();
+            if (params.length >= 2) {
+                const argsParam = params[1];
+                const typeObj = argsParam.getType();
+                if (typeObj.isObject() &&
+                    !typeObj.isArray() &&
+                    typeObj.getProperties().length > 0) {
+                    const props = typeObj.getProperties().map((p) => {
+                        const decl = p.getValueDeclaration() ?? p.getDeclarations()[0];
+                        const propType = decl
+                            ? decl
+                                .getType()
+                                .getText(decl)
+                                .replace(/import\("[^"]+"\)\./g, "")
+                            : "any";
+                        return `${p.getName()}: ${propType}`;
+                    });
+                    argsType = `{ ${props.join("; ")} }`;
+                    hasArgs = true;
+                }
+            }
+        }
+        // Extract return type
+        let returnType = this.inferReturnType(handlerFunc, sourceFile);
+        // Calculate import path relative to _generated directory
+        // sourceFile.getFilePath() gives absolute path, we need relative path like ../src/rpc-procedures
+        const filePath = sourceFile.getFilePath();
+        const srcDir = path.join(this.archlastPath, "src");
+        let relativePath = path.relative(srcDir, filePath);
+        // Remove .ts extension
+        relativePath = relativePath.replace(/\.ts$/, "");
+        // Create import path from _generated: ../src/filename
+        const importPath = `../src/${relativePath}`;
+        return {
+            name,
+            moduleName,
+            procedureType,
+            argsType,
+            returnType,
+            auth: authMode,
+            importPath,
+            hasArgs,
+        };
+    }
+    extractTypeInfo(callExpr, moduleName, name, type, sourceFile) {
+        const firstArg = callExpr.getArguments()[0];
+        let handlerFunc = null;
+        let authMode = undefined;
+        if (firstArg.getKind() === SyntaxKind.ArrowFunction) {
+            handlerFunc = firstArg.asKind(SyntaxKind.ArrowFunction);
+        }
+        else if (firstArg.getKind() === SyntaxKind.ObjectLiteralExpression) {
+            const obj = firstArg.asKind(SyntaxKind.ObjectLiteralExpression);
+            const handlerProp = obj?.getProperty("handler");
+            if (handlerProp && handlerProp.getKind() === SyntaxKind.PropertyAssignment) {
+                handlerFunc = handlerProp
+                    .asKind(SyntaxKind.PropertyAssignment)
+                    ?.getInitializer()
+                    ?.asKind(SyntaxKind.ArrowFunction);
+            }
+            // Extract auth mode
+            const authProp = obj?.getProperty("auth");
+            if (authProp && authProp.getKind() === SyntaxKind.PropertyAssignment) {
+                const authInit = authProp.asKind(SyntaxKind.PropertyAssignment)?.getInitializer();
+                if (authInit && authInit.getKind() === SyntaxKind.StringLiteral) {
+                    const authValue = authInit.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+                    if (authValue === "required" ||
+                        authValue === "optional" ||
+                        authValue === "public") {
+                        authMode = authValue;
+                    }
+                }
+            }
+        }
+        if (!handlerFunc)
+            return null;
+        let argsType = "Record<string, never>";
+        // Extract args from Zod schema
+        if (firstArg.getKind() === SyntaxKind.ObjectLiteralExpression) {
+            const obj = firstArg.asKind(SyntaxKind.ObjectLiteralExpression);
+            const argsProp = obj?.getProperty("args");
+            if (argsProp && argsProp.getKind() === SyntaxKind.PropertyAssignment) {
+                const argsInit = argsProp.asKind(SyntaxKind.PropertyAssignment)?.getInitializer();
+                if (argsInit) {
+                    // Handle both direct object literal { id: z.string() } and z.object({ id: z.string() })
+                    if (argsInit.getKind() === SyntaxKind.ObjectLiteralExpression) {
+                        argsType = this.parseZodSchema(argsInit);
+                    }
+                    else if (argsInit.getKind() === SyntaxKind.CallExpression) {
+                        // Check if it's z.object({ ... })
+                        const callText = argsInit.getText();
+                        if (callText.startsWith("z.object(") || callText.startsWith("v.object(")) {
+                            // Get the first argument of z.object() call
+                            const callExprArgs = argsInit.asKind(SyntaxKind.CallExpression)?.getArguments();
+                            if (callExprArgs && callExprArgs.length > 0) {
+                                const objectArg = callExprArgs[0];
+                                if (objectArg.getKind() === SyntaxKind.ObjectLiteralExpression) {
+                                    argsType = this.parseZodSchema(objectArg);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Fallback to inferred args type
+        if (argsType === "Record<string, never>") {
+            const params = handlerFunc.getParameters();
+            if (params.length >= 2) {
+                const argsParam = params[1];
+                const typeObj = argsParam.getType();
+                if (typeObj.isObject() &&
+                    !typeObj.isArray() &&
+                    typeObj.getProperties().length > 0) {
+                    const props = typeObj.getProperties().map((p) => {
+                        const decl = p.getValueDeclaration() ?? p.getDeclarations()[0];
+                        const propType = decl
+                            ? decl
+                                .getType()
+                                .getText(decl)
+                                .replace(/import\("[^"]+"\)\./g, "")
+                            : "any";
+                        return `${p.getName()}: ${propType}`;
+                    });
+                    argsType = `{ ${props.join("; ")} }`;
+                }
+            }
+        }
+        // Extract return type
+        let returnType = this.inferReturnType(handlerFunc, sourceFile);
+        return {
+            name,
+            moduleName,
+            type,
+            argsType,
+            returnType,
+            auth: authMode,
+        };
+    }
+    parseZodSchema(argsInit) {
+        const props = argsInit.asKind(SyntaxKind.ObjectLiteralExpression)?.getProperties();
+        const typeProps = [];
+        props?.forEach((p) => {
+            const prop = p.asKind(SyntaxKind.PropertyAssignment);
+            if (prop) {
+                const propName = prop.getName();
+                const init = prop.getInitializer();
+                let propType = "any";
+                let optional = false;
+                const text = init?.getText() || "";
+                if (text.includes("v.optional(") || text.includes("z.optional(")) {
+                    optional = true;
+                }
+                if (text.includes("v.string()") || text.includes("z.string()")) {
+                    propType = "string";
+                }
+                else if (text.includes("v.number()") || text.includes("z.number()")) {
+                    propType = "number";
+                }
+                else if (text.includes("v.boolean()") || text.includes("z.boolean()")) {
+                    propType = "boolean";
+                }
+                else if (text.includes("v.array(") || text.includes("z.array(")) {
+                    if (text.includes("v.object(") || text.includes("z.object(")) {
+                        propType = "any[]";
+                    }
+                    else if (text.includes("v.string()") || text.includes("z.string()")) {
+                        propType = "string[]";
+                    }
+                    else if (text.includes("v.number()") || text.includes("z.number()")) {
+                        propType = "number[]";
+                    }
+                    else {
+                        propType = "any[]";
+                    }
+                }
+                else if (text.includes("v.object(") || text.includes("z.object(")) {
+                    propType = "Record<string, any>";
+                }
+                if (optional) {
+                    propType = `${propType} | undefined`;
+                }
+                typeProps.push(`${propName}: ${propType};`);
+            }
+        });
+        return typeProps.length > 0 ? `{ ${typeProps.join(" ")} }` : "Record<string, never>";
+    }
+    inferReturnType(handlerFunc, sourceFile) {
+        const returnTypeNode = handlerFunc.getReturnType();
+        let returnTypeText = returnTypeNode.getText();
+        // Unwrap Promise<T> -> T
+        if (returnTypeText.startsWith("Promise<") && returnTypeText.endsWith(">")) {
+            returnTypeText = returnTypeText.slice(8, -1);
+        }
+        // Clean up return type if it contains import paths
+        returnTypeText = resolveImport(returnTypeText, sourceFile);
+        // Replace any with DataModel types even if TypeScript inferred it
+        if (returnTypeText.includes("any")) {
+            const body = handlerFunc.getBody();
+            if (body) {
+                const bodyText = body.getText();
+                // More flexible regex to handle multiline method chaining - match either direct call or chained call
+                let tableMatch = bodyText.match(/\.(query|list|get|insert|update|delete)\s*\(\s*["'](\w+)["']/);
+                const tableName = tableMatch ? tableMatch[2] : null;
+                if (tableName) {
+                    const tableType = `DataModel["${tableName}"]`;
+                    // Check what operation is being performed
+                    const isFindMany = bodyText.includes(".findMany()") || bodyText.includes(".list(");
+                    const isNullable = bodyText.includes(".findFirst()") ||
+                        bodyText.includes(".findUnique()") ||
+                        bodyText.includes(".get(");
+                    // Replace based on operation or existing type
+                    if (returnTypeText === "any[]" || (returnTypeText === "any" && isFindMany)) {
+                        returnTypeText = `${tableType}[]`;
+                    }
+                    else if (returnTypeText === "any | null" ||
+                        returnTypeText === "any|null" ||
+                        (returnTypeText === "any" && isNullable)) {
+                        returnTypeText = `${tableType} | null`;
+                    }
+                }
+            }
+        }
+        // If we got an object literal with 'any' fields, try to refine the types from the body
+        if (returnTypeText.includes(": any")) {
+            const body = handlerFunc.getBody();
+            if (body) {
+                const bodyText = body.getText();
+                // Extract field names from the return type
+                const fieldMatches = returnTypeText.matchAll(/(\w+):\s*any/g);
+                const fields = Array.from(fieldMatches, (m) => m[1]);
+                if (fields.length > 0) {
+                    // Extract table name for type inference (handle multiline)
+                    const tableMatch = bodyText.match(/ctx\.db\.(query|list|get|insert|update|delete)\s*\(\s*["'](\w+)["']/s);
+                    const tableName = tableMatch ? tableMatch[2] : null;
+                    const tableType = tableName ? `DataModel["${tableName}"]` : "any";
+                    const refinedFields = fields.map((field) => {
+                        // Check Promise.all destructuring first
+                        const destructureMatch = bodyText.match(/const\s*\[([^\]]+)\]\s*=\s*await\s+Promise\.all\s*\(\s*\[([\s\S]+?)\]\s*\)/);
+                        if (destructureMatch) {
+                            const vars = destructureMatch[1]
+                                .split(",")
+                                .map((v) => v.trim());
+                            const fieldIndex = vars.indexOf(field);
+                            if (fieldIndex !== -1) {
+                                const arrayContent = destructureMatch[2];
+                                const expressions = [];
+                                let currentExpr = "";
+                                let depth = 0;
+                                for (let i = 0; i < arrayContent.length; i++) {
+                                    const char = arrayContent[i];
+                                    if (char === "(" || char === "[" || char === "{")
+                                        depth++;
+                                    else if (char === ")" || char === "]" || char === "}")
+                                        depth--;
+                                    if (char === "," && depth === 0) {
+                                        expressions.push(currentExpr.trim());
+                                        currentExpr = "";
+                                    }
+                                    else {
+                                        currentExpr += char;
+                                    }
+                                }
+                                if (currentExpr.trim())
+                                    expressions.push(currentExpr.trim());
+                                if (expressions[fieldIndex]) {
+                                    const expr = expressions[fieldIndex].trim();
+                                    if (expr.includes(".count()"))
+                                        return `${field}: number`;
+                                    if (expr.includes(".findMany()") || expr.includes(".list("))
+                                        return `${field}: ${tableType}[]`;
+                                    if (expr.includes(".findFirst()") ||
+                                        expr.includes(".findUnique()") ||
+                                        expr.includes(".get("))
+                                        return `${field}: ${tableType} | null`;
+                                }
+                            }
+                        }
+                        // Look for variable declarations
+                        const declPattern = new RegExp(`(const|let|var)\\s+${field}\\s*=\\s*(?:await\\s+)?(.+?)(?:;|\\n)`, "s");
+                        const match = declPattern.exec(bodyText);
+                        if (match) {
+                            const rhs = match[2].trim();
+                            if (rhs.includes(".count()"))
+                                return `${field}: number`;
+                            if (rhs.includes(".findMany()") || rhs.includes(".list("))
+                                return `${field}: ${tableType}[]`;
+                            if (rhs.includes(".findFirst()") ||
+                                rhs.includes(".findUnique()") ||
+                                rhs.includes(".get("))
+                                return `${field}: ${tableType} | null`;
+                            if (rhs.includes(".insert("))
+                                return `${field}: string`;
+                            if (rhs.includes(".insertMany("))
+                                return `${field}: string[]`;
+                            if (rhs.includes(".updateMany()") || rhs.includes(".deleteMany()"))
+                                return `${field}: number`;
+                        }
+                        return `${field}: any`;
+                    });
+                    // Reconstruct the type
+                    returnTypeText = `{ ${refinedFields.join("; ")} }`;
+                }
+            }
+        }
+        // Better handling of common return types
+        if (returnTypeText === "any" || returnTypeText === "void" || returnTypeText === "never") {
+            // Try to infer from the body
+            const body = handlerFunc.getBody();
+            if (body) {
+                const bodyText = body.getText();
+                // Extract table name from db operations (handle multiline)
+                const tableMatch = bodyText.match(/ctx\.db\.(query|list|get|insert|update|delete)\s*\(\s*["'](\w+)["']/s);
+                const tableName = tableMatch ? tableMatch[2] : null;
+                const tableType = tableName ? `DataModel["${tableName}"]` : "any";
+                // Check for common db patterns (check more specific ones first)
+                if (bodyText.includes(".insertMany(")) {
+                    returnTypeText = "string[]";
+                }
+                else if (bodyText.includes(".updateMany(") || bodyText.includes(".deleteMany(")) {
+                    returnTypeText = "number";
+                }
+                else if (bodyText.includes(".findMany()") || bodyText.includes(".list(")) {
+                    returnTypeText = `${tableType}[]`;
+                }
+                else if (bodyText.includes(".findFirst()") ||
+                    bodyText.includes(".findUnique()")) {
+                    returnTypeText = `${tableType} | null`;
+                }
+                else if (bodyText.includes(".get(")) {
+                    returnTypeText = `${tableType} | null`;
+                }
+                else if (bodyText.includes(".count()")) {
+                    // Check if it's a final return or intermediate
+                    if (bodyText.match(/return\s+.*\.count\(\)/)) {
+                        returnTypeText = "number";
+                    }
+                }
+                else if (bodyText.includes(".insert(")) {
+                    returnTypeText = "string";
+                }
+                else if (bodyText.includes(".update(") || bodyText.includes(".delete(")) {
+                    // Check if it's the last operation
+                    if (bodyText.match(/return\s+.*\.(?:update|delete)\(/)) {
+                        returnTypeText = "void";
+                    }
+                }
+                // Object literal return - try to extract shape
+                const objMatch = bodyText.match(/return\s*{\s*([^}]+)}\s*;?/);
+                if (objMatch && returnTypeText === "any") {
+                    const fields = objMatch[1]
+                        .split(",")
+                        .map((f) => {
+                        const parts = f.trim().split(":");
+                        if (parts.length === 1) {
+                            // Shorthand property
+                            return parts[0].trim();
+                        }
+                        return parts[0].trim();
+                    })
+                        .filter(Boolean);
+                    if (fields.length > 0) {
+                        // Try to infer field types from variable declarations
+                        const fieldTypes = fields.map((field) => {
+                            // Check Promise.all destructuring first
+                            const destructureMatch = bodyText.match(/const\s*\[([^\]]+)\]\s*=\s*await\s+Promise\.all\s*\(\s*\[([\s\S]+?)\]\s*\)/);
+                            if (destructureMatch) {
+                                const vars = destructureMatch[1]
+                                    .split(",")
+                                    .map((v) => v.trim());
+                                const fieldIndex = vars.indexOf(field);
+                                if (fieldIndex !== -1) {
+                                    const arrayContent = destructureMatch[2];
+                                    const expressions = [];
+                                    let currentExpr = "";
+                                    let depth = 0;
+                                    for (let i = 0; i < arrayContent.length; i++) {
+                                        const char = arrayContent[i];
+                                        if (char === "(" || char === "[" || char === "{")
+                                            depth++;
+                                        else if (char === ")" || char === "]" || char === "}")
+                                            depth--;
+                                        if (char === "," && depth === 0) {
+                                            expressions.push(currentExpr.trim());
+                                            currentExpr = "";
+                                        }
+                                        else {
+                                            currentExpr += char;
+                                        }
+                                    }
+                                    if (currentExpr.trim())
+                                        expressions.push(currentExpr.trim());
+                                    if (expressions[fieldIndex]) {
+                                        const expr = expressions[fieldIndex].trim();
+                                        if (expr.includes(".count()"))
+                                            return `${field}: number`;
+                                        if (expr.includes(".findMany()") || expr.includes(".list("))
+                                            return `${field}: ${tableType}[]`;
+                                        if (expr.includes(".findFirst()") ||
+                                            expr.includes(".findUnique()") ||
+                                            expr.includes(".get("))
+                                            return `${field}: ${tableType} | null`;
+                                    }
+                                }
+                            }
+                            // More comprehensive field type detection - handle await and multiline
+                            const fieldDeclPattern = new RegExp(`(const|let|var)\\s+${field}\\s*=\\s*(?:await\\s+)?(.+?)(?:;|\\n)`, "s");
+                            const fieldDecl = fieldDeclPattern.exec(bodyText);
+                            if (fieldDecl) {
+                                const rhs = fieldDecl[2].trim();
+                                if (rhs.includes(".count()"))
+                                    return `${field}: number`;
+                                if (rhs.includes(".findMany()") || rhs.includes(".list("))
+                                    return `${field}: ${tableType}[]`;
+                                if (rhs.includes(".findFirst()") ||
+                                    rhs.includes(".findUnique()") ||
+                                    rhs.includes(".get("))
+                                    return `${field}: ${tableType} | null`;
+                                if (rhs.includes(".insert("))
+                                    return `${field}: string`;
+                                if (rhs.includes(".insertMany("))
+                                    return `${field}: string[]`;
+                                if (rhs.includes(".updateMany()") || rhs.includes(".deleteMany()"))
+                                    return `${field}: number`;
+                                if (rhs.includes(".update(") || rhs.includes(".delete("))
+                                    return `${field}: void`;
+                            }
+                            return `${field}: any`;
+                        });
+                        returnTypeText = `{ ${fieldTypes.join("; ")} }`;
+                    }
+                }
+            }
+        }
+        // Clean up complex types
+        returnTypeText = returnTypeText.replace(/import\("[^"]+"\)\./g, "");
+        return returnTypeText;
+    }
+    async generateDataModelFromSchema() {
+        // Check for both single file and folder-based schemas
+        const schemaPath = join(this.archlastPath, "src", "schema.ts");
+        const schemaFolderPath = join(this.archlastPath, "src", "schema");
+        const schemaIndexPath = join(schemaFolderPath, "index.ts");
+        let schemaContent = "";
+        let schemaSource = "";
+        if (await Bun.file(schemaPath).exists()) {
+            schemaContent = await Bun.file(schemaPath).text();
+            schemaSource = "schema.ts";
+            console.log(`Reading schema from ${schemaPath}`);
+        }
+        else if (await Bun.file(schemaIndexPath).exists()) {
+            schemaContent = await Bun.file(schemaIndexPath).text();
+            schemaSource = "schema/index.ts";
+            console.log(`Reading schema from ${schemaIndexPath}`);
+        }
+        else {
+            // Scan folder for schema files
+            const folderFiles = await this.scanSchemaFolder(schemaFolderPath);
+            schemaContent = folderFiles.map(f => f.content).join("\n");
+            schemaSource = "schema/*.ts";
+            console.log(`Reading schema from folder: ${schemaFolderPath}`);
+        }
+        // Extract table definitions from schema
+        // Supports both:
+        // 1. Standalone: export const tasks = defineTable({ ...
+        // 2. Inside defineSchema: tasks: defineTable({ ...
+        // Regex matches both patterns
+        const tableMatches = schemaContent.matchAll(/(?:export\s+(?:const|let)\s+)?(\w+)\s*(?::\s*\w+)?\s*[:=]\s*defineTable\s*\(\s*\{([\s\S]+?)\n\s*}(?:,\s*({[\s\S]+?\n\s*}))?\s*\)/g);
+        const tables = {};
+        for (const match of tableMatches) {
+            const tableName = match[1];
+            const fields = match[2];
+            const options = match[3];
+            console.log(`Processing table: ${tableName}`);
+            tables[tableName] = {
+                fields: [],
+                createFields: [],
+                updateFields: [],
+                fieldMetadata: {}
+            };
+            // Match field definitions line by line to avoid greedy regex issues
+            const lines = fields.split("\n");
+            for (const line of lines) {
+                const fieldMatch = line.match(/^\s*(\w+):\s*v\.([a-zA-Z]+)\(([^)]*)\)(.*)/);
+                if (!fieldMatch)
+                    continue;
+                const fieldName = fieldMatch[1];
+                console.log(`  Found field: ${fieldName}`);
+                if (fieldName === "_id")
+                    continue;
+                const baseType = fieldMatch[2];
+                const modifiers = fieldMatch[4] || "";
+                let tsType = "any";
+                switch (baseType) {
+                    case "string":
+                        tsType = "string";
+                        break;
+                    case "number":
+                        tsType = "number";
+                        break;
+                    case "boolean":
+                        tsType = "boolean";
+                        break;
+                    case "id":
+                        tsType = "string";
+                        break;
+                    case "date":
+                        tsType = "Date";
+                        break;
+                    case "datetime":
+                        tsType = "Date";
+                        break;
+                    case "array": {
+                        const inner = (fieldMatch[3] || "").trim();
+                        if (inner.includes("v.string") || inner.includes("z.string")) {
+                            tsType = "string[]";
+                        }
+                        else if (inner.includes("v.number") || inner.includes("z.number")) {
+                            tsType = "number[]";
+                        }
+                        else if (inner.includes("v.boolean") || inner.includes("z.boolean")) {
+                            tsType = "boolean[]";
+                        }
+                        else {
+                            tsType = "any[]";
+                        }
+                        break;
+                    }
+                    case "object":
+                        tsType = "Record<string, any>";
+                        break;
+                }
+                const isOptional = modifiers.includes(".optional()") || modifiers.includes(".nullable()");
+                const isAutoGenerated = modifiers.includes(".autoGenerated()");
+                const isCreatedNow = modifiers.includes(".createdNow()");
+                const isUpdateNow = modifiers.includes(".updateNow()");
+                const isDefault = modifiers.includes(".default(");
+                // Calculate modifier flags
+                let modFlags = 0;
+                if (isCreatedNow)
+                    modFlags |= (1 << 0); // CreatedNow
+                if (isUpdateNow)
+                    modFlags |= (1 << 1); // UpdateNow
+                if (isAutoGenerated)
+                    modFlags |= (1 << 2); // AutoGenerated
+                if (modifiers.includes(".searchable()"))
+                    modFlags |= (1 << 3); // Searchable
+                if (isDefault)
+                    modFlags |= (1 << 4); // HasDefault
+                if (modifiers.includes(".unique()") || modifiers.includes(".applyUnique()"))
+                    modFlags |= (1 << 5); // Unique
+                if (modifiers.includes(".index()") || modifiers.includes(".applyIndex()"))
+                    modFlags |= (1 << 6); // Indexed
+                if (isOptional)
+                    modFlags |= (1 << 7); // Nullable
+                tables[tableName].fieldMetadata[fieldName] = {
+                    modifiers: modFlags,
+                    type: tsType,
+                    optional: isOptional
+                };
+                // Add to base DataModel type
+                tables[tableName].fields.push(`    ${fieldName}${isOptional ? "?" : ""}: ${tsType};`);
+                // Add to CreateInput if not auto-generated and not a system field
+                if (!isAutoGenerated &&
+                    fieldName !== "createdAt" &&
+                    fieldName !== "updatedAt" &&
+                    fieldName !== "_id" &&
+                    fieldName !== "_collection") {
+                    tables[tableName].createFields.push(`    ${fieldName}?: ${tsType};`);
+                }
+                // Add to UpdateInput if not auto-generated and not read-only
+                if (!isAutoGenerated &&
+                    fieldName !== "createdAt" &&
+                    fieldName !== "_id" &&
+                    fieldName !== "_collection") {
+                    tables[tableName].updateFields.push(`    ${fieldName}?: ${tsType};`);
+                }
+            }
+            // Parse relationships from options
+            if (options) {
+                const relBlockMatch = options.match(/relationships:\s*{([\s\S]+?)}/);
+                if (relBlockMatch) {
+                    const relContent = relBlockMatch[1];
+                    const relMatches = relContent.matchAll(/(\w+):\s*(hasMany|belongsTo|hasOne)\(["'](\w+)["']/g);
+                    for (const relMatch of relMatches) {
+                        const relName = relMatch[1];
+                        const relType = relMatch[2];
+                        const targetTable = relMatch[3];
+                        let tsType = "any";
+                        if (relType === "hasMany") {
+                            tsType = `DataModel["${targetTable}"][]`;
+                        }
+                        else {
+                            tsType = `DataModel["${targetTable}"] | null`;
+                        }
+                        // Relationships are always optional in the DataModel as they need to be loaded
+                        tables[tableName].fields.push(`    ${relName}?: ${tsType};`);
+                        console.log(`  Found relationship: ${relName} -> ${targetTable} (${relType})`);
+                    }
+                }
+            }
+            if (tables[tableName].fields.length === 0) {
+                console.log(`  No fields found for table ${tableName}. Raw fields content:\n${fields}`);
+            }
+        }
+        // Generate DataModel type
+        const tableTypes = Object.entries(tables)
+            .map(([name, data]) => {
+            return `  ${name}: {\n${data.fields.join("\n")}\n    _id: string;\n    _collection: "${name}";\n  };`;
+        })
+            .join("\n");
+        const dataModel = `export type DataModel = {\n${tableTypes}\n};`;
+        // Generate Input Types
+        const inputTypesList = [];
+        for (const [name, data] of Object.entries(tables)) {
+            const pascalName = name.charAt(0).toUpperCase() + name.slice(1);
+            inputTypesList.push(`export type ${pascalName}CreateInput = {\n${data.createFields.length > 0 ? data.createFields.join("\n") : "    // All fields are auto-generated"}\n};`);
+            inputTypesList.push(`export type ${pascalName}UpdateInput = {\n${data.updateFields.length > 0 ? data.updateFields.join("\n") : "    // All fields are read-only"}\n};`);
+        }
+        const inputTypes = `// ============================================================================
+// PRISMA-STYLE INPUT TYPES
+// ============================================================================
+
+${inputTypesList.join("\n\n")}
+
+export type GeneratedInputModels = {
+${Object.keys(tables).map(name => {
+            const pascalName = name.charAt(0).toUpperCase() + name.slice(1);
+            return `    ${name}: {
+        create: ${pascalName}CreateInput;
+        update: ${pascalName}UpdateInput;
+    };`;
+        }).join("\n")}
+};
+`;
+        // Generate Relationship Types
+        const relationshipTypesList = [];
+        for (const [name, data] of Object.entries(tables)) {
+            const pascalName = name.charAt(0).toUpperCase() + name.slice(1);
+            // Extract relationship fields from the base type
+            const relationshipFields = data.fields.filter(f => f.includes("DataModel["));
+            if (relationshipFields.length > 0) {
+                relationshipTypesList.push(`export type ${pascalName}WithRelations = DataModel["${name}"] & {\n${relationshipFields.join("\n")}\n};`);
+            }
+            else {
+                relationshipTypesList.push(`export type ${pascalName}WithRelations = DataModel["${name}"];`);
+            }
+        }
+        const relationshipTypes = `// ============================================================================
+// RELATIONSHIP TYPES
+// ============================================================================
+
+${relationshipTypesList.join("\n\n")}
+`;
+        return { dataModel, inputTypes, relationshipTypes };
+    }
+    /**
+     * Scan schema folder for all .ts files
+     */
+    async scanSchemaFolder(folderPath) {
+        const files = [];
+        // Check if folder exists
+        try {
+            const entryNames = fs.readdirSync(folderPath);
+            for (const name of entryNames) {
+                if (!name.endsWith(".ts"))
+                    continue;
+                if (name === "index.ts")
+                    continue;
+                const filePath = join(folderPath, name);
+                // Skip directories
+                const stat = fs.statSync(filePath);
+                if (stat.isDirectory())
+                    continue;
+                const content = fs.readFileSync(filePath, "utf-8");
+                files.push({ filePath, content });
+            }
+        }
+        catch {
+            // Folder doesn't exist
+        }
+        return files;
+    }
+    async generateApiTypes(typeInfos) {
+        let output = `// This file is auto-generated by Archlast CLI\n`;
+        output += `// Do not edit manually\n\n`;
+        output += `import type { FunctionReference } from '@archlast/client';\n\n`;
+        // Generate DataModel type from schema
+        const { dataModel: dataModelType, inputTypes, relationshipTypes } = await this.generateDataModelFromSchema();
+        output += `// Data model types\n${dataModelType}\n\n`;
+        // Generate ApiDefinition
+        output += `export type ApiDefinition = {\n`;
+        for (const info of typeInfos) {
+            const fullName = `${info.moduleName}.${info.name}`;
+            output += `  "${fullName}": {\n`;
+            output += `    type: "${info.type}";\n`;
+            output += `    args: ${info.argsType};\n`;
+            output += `    return: ${info.returnType};\n`;
+            if (info.auth) {
+                output += `    auth: "${info.auth}";\n`;
+            }
+            output += `  };\n`;
+        }
+        output += `};\n\n`;
+        // Generate api object
+        output += `export const api = {\n`;
+        const groupedByModule = typeInfos.reduce((acc, info) => {
+            if (!acc[info.moduleName])
+                acc[info.moduleName] = [];
+            acc[info.moduleName].push(info);
+            return acc;
+        }, {});
+        for (const [moduleName, funcs] of Object.entries(groupedByModule)) {
+            // Quote module name if it contains special characters
+            const quotedModuleName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(moduleName)
+                ? moduleName
+                : `"${moduleName}"`;
+            output += `  ${quotedModuleName}: {\n`;
+            for (const func of funcs) {
+                const fullName = `${moduleName}.${func.name}`;
+                const authStr = func.auth ? `, _auth: '${func.auth}'` : "";
+                output += `    ${func.name}: { _name: '${fullName}', _type: '${func.type}', _args: undefined as any, _return: undefined as any${authStr} } as FunctionReference<'${func.type}', '${fullName}', ${func.argsType}, ${func.returnType}>,\n`;
+            }
+            output += `  },\n`;
+        }
+        output += `} as const;\n\n`;
+        output += `export type Api = typeof api;\n`;
+        return output;
+    }
+    async generateRpcTypes(rpcTypeInfos) {
+        let output = `// This file is auto-generated by Archlast CLI\n`;
+        output += `// Do not edit manually\n\n`;
+        output += `// tRPC Procedure Type Definitions\n`;
+        output += `// This file defines the input/output types for all RPC procedures\n`;
+        output += `// Use with @trpc/client for fully typed API calls\n\n`;
+        // Import only DataModel - no tRPC dependencies
+        output += `import type { DataModel } from './server';\n\n`;
+        // Group procedures by module name
+        const groupedByModule = rpcTypeInfos.reduce((acc, info) => {
+            if (!acc[info.moduleName])
+                acc[info.moduleName] = [];
+            acc[info.moduleName].push(info);
+            return acc;
+        }, {});
+        // Generate typescript types for each procedure
+        output += `// ============================================\n`;
+        output += `// Procedure Input/Output Types\n`;
+        output += `// ============================================\n\n`;
+        for (const [moduleName, procs] of Object.entries(groupedByModule)) {
+            // Convert hyphenated names to camelCase
+            const safeModuleName = moduleName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+            const pascalModuleName = safeModuleName.charAt(0).toUpperCase() + safeModuleName.slice(1);
+            output += `// ${pascalModuleName} Module\n`;
+            for (const proc of procs) {
+                output += `export type ${proc.name}Input = ${proc.argsType};\n`;
+                output += `export type ${proc.name}Output = ${proc.returnType};\n`;
+            }
+            output += `\n`;
+        }
+        // Generate a combined namespace for all procedures
+        output += `// ============================================\n`;
+        output += `// All Procedures Types\n`;
+        output += `// ============================================\n\n`;
+        output += `export interface RpcProcedures {\n`;
+        for (const [moduleName, procs] of Object.entries(groupedByModule)) {
+            const safeModuleName = moduleName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+            output += `  ${safeModuleName}: {\n`;
+            for (const proc of procs) {
+                output += `    ${proc.name}: {\n`;
+                output += `      input: ${proc.argsType};\n`;
+                output += `      output: ${proc.returnType};\n`;
+                output += `    };\n`;
+            }
+            output += `  };\n`;
+        }
+        output += `}\n\n`;
+        // Export list of all procedure names
+        output += `// Procedure names for reference\n`;
+        output += `export const PROCEDURES = {\n`;
+        for (const [moduleName, procs] of Object.entries(groupedByModule)) {
+            const safeModuleName = moduleName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+            output += `  ${safeModuleName}: [\n`;
+            for (const proc of procs) {
+                output += `    "${proc.name}",\n`;
+            }
+            output += `  ],\n`;
+        }
+        output += `} as const;\n`;
+        return output;
+    }
+    /**
+     * Generate runtime tRPC router definition file
+     * This creates a real t.router() that imports and wraps the actual RPC procedures
+     */
+    async generateTrpcRouter(rpcTypeInfos) {
+        let output = `// This file is auto-generated by Archlast CLI\n`;
+        output += `// Do not edit manually\n\n`;
+        output += `// tRPC Router Runtime Definition\n`;
+        output += `// This file creates a real tRPC router that wraps the RPC procedures\n`;
+        output += `// Client: Import type { AppRouter } for full type safety\n\n`;
+        // Import tRPC and actual RpcCtx type from @archlast/server
+        output += `import { initTRPC } from "@trpc/server";\n`;
+        output += `import type { RpcCtx } from "@archlast/server/functions/types";\n\n`;
+        // Group procedures by import path (to avoid duplicate imports)
+        const procsByImportPath = rpcTypeInfos.reduce((acc, info) => {
+            if (!acc[info.importPath])
+                acc[info.importPath] = [];
+            acc[info.importPath].push(info);
+            return acc;
+        }, {});
+        // Generate imports for each source file
+        output += `// ============================================\n`;
+        output += `// Import RPC Procedures\n`;
+        output += `// ============================================\n\n`;
+        for (const [importPath, procs] of Object.entries(procsByImportPath)) {
+            const exportNames = procs.map((p) => p.name).join(", ");
+            output += `import { ${exportNames} } from "${importPath}";\n`;
+        }
+        output += `\n`;
+        // Initialize tRPC with proper context type
+        output += `// ============================================\n`;
+        output += `// Initialize tRPC\n`;
+        output += `// ============================================\n\n`;
+        output += `const t = initTRPC.context<RpcCtx>().create();\n\n`;
+        // Build the router
+        output += `// ============================================\n`;
+        output += `// Build Runtime Router\n`;
+        output += `// ============================================\n\n`;
+        output += `/**\n`;
+        output += ` * tRPC Router\n`;
+        output += ` * Wraps the RPC procedures in tRPC's t.procedure API\n`;
+        output += ` * Client: Use createTRPCClient<typeof appRouter> for type-safe calls\n`;
+        output += ` */\n`;
+        output += `export const appRouter = t.router({\n`;
+        // Group procedures by module name for nested router structure
+        const groupedByModule = rpcTypeInfos.reduce((acc, info) => {
+            if (!acc[info.moduleName])
+                acc[info.moduleName] = [];
+            acc[info.moduleName].push(info);
+            return acc;
+        }, {});
+        for (const [moduleName, procs] of Object.entries(groupedByModule)) {
+            // Convert hyphenated names to camelCase
+            const safeModuleName = moduleName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+            output += `  ${safeModuleName}: t.router({\n`;
+            for (const proc of procs) {
+                // Generate the procedure wrapper
+                // We access the procedure's args and handler from the imported object
+                output += `    ${proc.name}: t.procedure`;
+                // Add input validation if args exist (use non-null assertion since args is optional in RpcDefinition)
+                if (proc.hasArgs) {
+                    output += `.input(${proc.name}.args!)`;
+                }
+                // Add query or mutation
+                if (proc.procedureType === "query") {
+                    output += `.query(async ({ ctx, input }) => {\n`;
+                }
+                else {
+                    output += `.mutation(async ({ ctx, input }) => {\n`;
+                }
+                // Call the original handler
+                output += `      return ${proc.name}.handler(ctx, input);\n`;
+                output += `    }),\n`;
+            }
+            output += `  }),\n`;
+        }
+        output += `});\n\n`;
+        // Export the AppRouter type
+        output += `// ============================================\n`;
+        output += `// Export Router Type\n`;
+        output += `// ============================================\n\n`;
+        output += `export type AppRouter = typeof appRouter;\n\n`;
+        // Export tRPC instance for server use
+        output += `export { t };\n`;
+        return output;
+    }
+    async generateServerTypes() {
+        const { dataModel, inputTypes, relationshipTypes } = await this.generateDataModelFromSchema();
+        return `// This file is auto-generated by Archlast CLI
+// Do not edit manually
+
+import "reflect-metadata";
+import { z } from "zod";
+import type { FunctionReference } from "@archlast/client";
+import type { GenericDatabaseReader, GenericDatabaseWriter, RelationsMap, Document } from "@archlast/server/db/interfaces";
+import type { AuthContext } from "@archlast/server/auth/interfaces";
+import type { IQueryable, IMutableQueryable, IDbSet, IChangeTracker } from "@archlast/server/repository/interfaces";
+import type { DbContext, EntityEntry, EntityState, IRepository } from "@archlast/server/repository/factory";
+import type { SchedulerService } from "@archlast/server/jobs/scheduler";
+import type { JobQueue } from "@archlast/server/jobs/queue";
+import type { Storage } from "@archlast/server/storage/types";
+import type { LogService } from "@archlast/server/logging/logger";
+import { WebhookGuard } from "@archlast/server/webhook/definition";
+
+
+// ============================================================================
+// DATA MODEL
+// ============================================================================
+
+${dataModel}
+
+// Re-export validator
+export { v } from "@archlast/server/schema/validators";
+
+${inputTypes}
+
+${relationshipTypes}
+
+// ============================================================================
+// DI DECORATORS (inline implementations)
+// ============================================================================
+
+export interface InjectableOptions {
+    provide: string;
+    useFactory?: string;
+    scope?: "singleton" | "transient";
+}
+
+export function Injectable(options?: InjectableOptions): ClassDecorator {
+    return function <TFunction extends Function>(target: TFunction): TFunction {
+        // Store metadata on the constructor itself
+        (target as any).__injectable__ = options || { provide: target.name };
+        return target;
+    };
+}
+
+export function Factory(token: string): ClassDecorator {
+    return function <TFunction extends Function>(target: TFunction): TFunction {
+        // Store metadata on the constructor itself
+        (target as any).__factory__ = token;
+        return target;
+    };
+}
+
+// ============================================================================
+// RE-EXPORTS (webhook guards from package)
+// ============================================================================
+
+// Import and re-export webhook guards from the server package
+// Note: When deployed, these will be available from @archlast/server/webhook/guard
+export { createWebhookGuard, createHmacGuard } from "@archlast/server/webhook/guard";
+
+// ============================================================================
+// CONTEXT TYPES
+// ============================================================================
+
+/**
+ * DI methods available in function contexts
+ */
+export interface DIContext {
+    /**
+     * Resolve a singleton service by token
+     * @example ctx.service<IUserService>("UserService")
+     */
+    service<T>(token: string): T;
+
+    /**
+     * Resolve a factory implementation by token and implementation key
+     * @example ctx.factory<IEmailProvider>("EmailProvider", "Resend")
+     */
+    factory<T>(token: string, implementation?: string): T;
+}
+
+/**
+ * Server context contains all server-wide dependencies
+ */
+export interface ServerContext extends DIContext {
+   auth: AuthContext;
+    db: GenericDatabaseWriter<DataModel>;
+    /** Uncached database client for system functions */
+    rawDb: GenericDatabaseWriter<DataModel>;
+    /** Repository with EF Core DbContext pattern - supports change tracking and SaveChangesAsync() */
+    repository: IRepository<DataModel, GeneratedInputModels>;
+    storage: Storage;
+    logger: LogService;
+    scheduler: SchedulerService;
+    jobQueue: JobQueue;
+}
+
+/**
+ * Query context - read-only database operations
+ */
+export interface QueryCtx extends DIContext {
+    auth: AuthContext;
+    db: GenericDatabaseReader<DataModel>;
+    /** Uncached database client for system functions */
+    rawDb: GenericDatabaseReader<DataModel>;
+    /** Repository with EF Core DbContext pattern - query-only access but with FindAsync, Find, Entry methods */
+    repository: IRepository<DataModel, GeneratedInputModels>;
+    storage: Storage;
+    logger: LogService;
+    scheduler: SchedulerService;
+    jobQueue: JobQueue;
+}
+
+/**
+ * Mutation context - read/write database operations
+ */
+export interface MutationCtx extends DIContext {
+    auth: AuthContext;
+    db: GenericDatabaseWriter<DataModel>;
+    /** Uncached database client for system functions that need fresh data */
+    rawDb: GenericDatabaseWriter<DataModel>;
+    /** Repository with EF Core DbContext pattern - supports change tracking and SaveChangesAsync() with input types */
+    repository: IRepository<DataModel, GeneratedInputModels>;
+    storage: Storage;
+    logger: LogService;
+    scheduler: SchedulerService;
+    jobQueue: JobQueue;
+}
+
+/**
+ * Action context - full read/write database access for side effects and external APIs
+ */
+export interface ActionCtx extends DIContext {
+    auth: AuthContext;
+    db: GenericDatabaseWriter<DataModel>;
+    /** Uncached database client for system functions that need fresh data */
+    rawDb: GenericDatabaseWriter<DataModel>;
+    /** Repository with EF Core DbContext pattern - supports change tracking and SaveChangesAsync() with input types */
+    repository: IRepository<DataModel, GeneratedInputModels>;
+    storage: Storage;
+    logger: LogService;
+    scheduler: SchedulerService;
+    jobQueue: JobQueue;
+}
+
+/**
+ * Service context - request-scoped context for services
+ */
+export interface ServiceContext extends DIContext {
+    auth: AuthContext;
+    db: GenericDatabaseWriter<DataModel>;
+    /** Uncached database client for system functions that need fresh data */
+    rawDb: GenericDatabaseWriter<DataModel>;
+    /** Repository with EF Core DbContext pattern - supports change tracking and SaveChangesAsync() with input types */
+    repository: IRepository<DataModel, GeneratedInputModels>;
+    storage: Storage;
+    logger: LogService;
+    scheduler: SchedulerService;
+    jobQueue: JobQueue;
+}
+
+/**
+ * HTTP request object with path parameters and query params
+ */
+export interface HttpRequest {
+    raw: Request;
+    method: string;
+    path: string;
+    headers: Headers;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    json<T = unknown>(): Promise<T>;
+    text(): Promise<string>;
+    formData(): Promise<FormData>;
+    blob(): Promise<Blob>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+}
+
+/**
+ * HTTP context - includes server context and request
+ */
+export interface HttpCtx extends DIContext {
+    auth: AuthContext;
+    db: GenericDatabaseWriter<DataModel>;
+    repository: { [K in keyof DataModel]: IMutableQueryable<DataModel[K]> };
+    storage: Storage;
+    logger: LogService;
+    scheduler: SchedulerService;
+    jobQueue: JobQueue;
+    server: ServerContext;
+    req: HttpRequest;
+}
+
+/**
+ * Webhook context - similar to MutationCtx
+ */
+export interface WebhookCtx extends DIContext {
+    auth: AuthContext;
+    db: GenericDatabaseWriter<DataModel>;
+    repository: { [K in keyof DataModel]: IMutableQueryable<DataModel[K]> };
+    storage: Storage;
+    logger: LogService;
+    scheduler: SchedulerService;
+    jobQueue: JobQueue;
+    server: ServerContext;
+    req: Request;
+}
+
+/**
+ * RPC (tRPC-style) context - For type-safe public API procedures
+ * Similar to QueryCtx/MutationCtx but designed for external RPC calls
+ */
+export interface RpcCtx<
+    DataModel extends Record<string, Document> = any,
+    Relations extends RelationsMap<DataModel> = RelationsMap<DataModel>,
+> extends DIContext {
+    auth: AuthContext;
+    db: GenericDatabaseWriter<DataModel, Relations>;
+    repository: { [K in keyof DataModel]: IMutableQueryable<DataModel[K]> };
+    storage: Storage;
+    logger: LogService;
+    scheduler: SchedulerService;
+    jobQueue: JobQueue;
+    server: ServerContext;
+}
+
+export type QueryHandler<Args, Return> = (ctx: QueryCtx, args: Args) => Promise<Return>;
+export type MutationHandler<Args, Return> = (ctx: MutationCtx, args: Args) => Promise<Return>;
+export type ActionHandler<Args, Return> = (ctx: ActionCtx, args: Args) => Promise<Return>;
+export type HttpHandler<Args, Return> = (ctx: HttpCtx, args: Args) => Promise<Return> | Return;
+export type WebhookHandler<Args, Return> = (ctx: WebhookCtx, args: Args) => Promise<Return> | Return;
+
+export type FunctionType = "query" | "mutation" | "action" | "http" | "webhook";
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+
+/**
+ * Auth mode determines authentication requirements for a function
+ * - "required" (default): Authentication is required (session or API key)
+ * - "optional": Authentication is optional (ctx.auth may be unauthenticated)
+ * - "public": No authentication required (function is publicly accessible)
+ */
+export type AuthMode = "required" | "optional" | "public";
+
+export interface FunctionDefinition {
+    type: FunctionType;
+    handler: Function;
+    args?: z.ZodType<any>;
+    name?: string; // Assigned at registration
+
+    /**
+     * Auth mode - defaults to "required"
+     */
+    auth?: AuthMode;
+
+    /**
+     * Required permissions - checked before handler execution
+     * Example: ["tasks.read", "tasks.write"]
+     */
+    permissions?: string[];
+
+    /**
+     * Allowed scopes for API key auth
+     * If not specified, function is accessible to all auth types
+     */
+    scopes?: ("query" | "mutation" | "action")[];
+}
+
+/**
+ * HTTP-specific function definition
+ */
+export interface HttpDefinition<Args = unknown, Return = unknown> {
+    type: "http";
+    method: HttpMethod;
+    path: string;
+    handler: HttpHandler<Args, Return>;
+    auth?: AuthMode;
+    permissions?: string[];
+    middleware?: Array<(ctx: HttpCtx, next: () => Promise<Response>) => Promise<Response>>;
+}
+
+/**
+ * Webhook-specific function definition
+ */
+export interface WebhookDefinition<Event = unknown, Return = unknown> {
+    type: "webhook";
+    method: HttpMethod;
+    path: string;
+    handler: WebhookHandler<Event, Return>;
+    eventSchema?: z.ZodType<Event>;
+    guards?: WebhookGuard[];
+    auth?: AuthMode;
+}
+
+// Overload for config object with args (explicit z.ZodType)
+export function query<Args extends z.ZodType<any, any, any>, Return>(config: {
+    args: Args;
+    handler: QueryHandler<z.infer<Args>, Return>;
+    auth?: AuthMode;
+    permissions?: string[];
+    scopes?: ("query" | "mutation" | "action")[];
+}): FunctionDefinition;
+// Overload for config object with args (z.ZodRawShape)
+export function query<Args extends z.ZodRawShape, Return>(config: {
+    args: Args;
+    handler: QueryHandler<z.infer<z.ZodObject<Args>>, Return>;
+    auth?: AuthMode;
+    permissions?: string[];
+    scopes?: ("query" | "mutation" | "action")[];
+}): FunctionDefinition;
+// Overload for config object without args
+export function query<Return>(config: {
+    handler: QueryHandler<Record<string, never>, Return>;
+    auth?: AuthMode;
+    permissions?: string[];
+    scopes?: ("query" | "mutation" | "action")[];
+}): FunctionDefinition;
+// Overload for simple handler (no args)
+export function query<Return>(
+    handler: QueryHandler<Record<string, never>, Return>
+): FunctionDefinition;
+export function query(configOrHandler: any): FunctionDefinition {
+    if (typeof configOrHandler === "function") {
+        return {
+            type: "query",
+            handler: configOrHandler,
+            auth: "required", // default
+        };
+    }
+    // If args is already a ZodType (z.object, etc.), use it directly; otherwise wrap with z.object()
+    const args = configOrHandler.args && typeof configOrHandler.args === "object" && "parse" in configOrHandler.args
+        ? configOrHandler.args
+        : configOrHandler.args
+            ? z.object(configOrHandler.args)
+            : undefined;
+
+    return {
+        type: "query",
+        handler: configOrHandler.handler,
+        args,
+        auth: configOrHandler.auth || "required",
+        permissions: configOrHandler.permissions,
+        scopes: configOrHandler.scopes,
+    };
+}
+
+// Overload for config object with args (explicit z.ZodType)
+export function mutation<Args extends z.ZodType<any, any, any>, Return>(config: {
+    args: Args;
+    handler: MutationHandler<z.infer<Args>, Return>;
+    auth?: AuthMode;
+    permissions?: string[];
+    scopes?: ("query" | "mutation" | "action")[];
+}): FunctionDefinition;
+// Overload for config object with args (z.ZodRawShape)
+export function mutation<Args extends z.ZodRawShape, Return>(config: {
+    args: Args;
+    handler: MutationHandler<z.infer<z.ZodObject<Args>>, Return>;
+    auth?: AuthMode;
+    permissions?: string[];
+    scopes?: ("query" | "mutation" | "action")[];
+}): FunctionDefinition;
+// Overload for config object without args
+export function mutation<Return>(config: {
+    handler: MutationHandler<Record<string, never>, Return>;
+    auth?: AuthMode;
+    permissions?: string[];
+    scopes?: ("query" | "mutation" | "action")[];
+}): FunctionDefinition;
+// Overload for simple handler (no args)
+export function mutation<Return>(
+    handler: MutationHandler<Record<string, never>, Return>
+): FunctionDefinition;
+export function mutation(configOrHandler: any): FunctionDefinition {
+    if (typeof configOrHandler === "function") {
+        return {
+            type: "mutation",
+            handler: configOrHandler,
+            auth: "required", // default
+        };
+    }
+    // If args is already a ZodType (z.object, etc.), use it directly; otherwise wrap with z.object()
+    const args = configOrHandler.args && typeof configOrHandler.args === "object" && "parse" in configOrHandler.args
+        ? configOrHandler.args
+        : configOrHandler.args
+            ? z.object(configOrHandler.args)
+            : undefined;
+
+    return {
+        type: "mutation",
+        handler: configOrHandler.handler,
+        args,
+        auth: configOrHandler.auth || "required",
+        permissions: configOrHandler.permissions,
+        scopes: configOrHandler.scopes,
+    };
+}
+
+export function action<Args = unknown, Return = unknown>(
+    handlerOrConfig:
+        | ActionHandler<Args, Return>
+        | {
+              handler: ActionHandler<Args, Return>;
+              auth?: AuthMode;
+              permissions?: string[];
+              scopes?: ("query" | "mutation" | "action")[];
+          }
+): FunctionDefinition {
+    if (typeof handlerOrConfig === "function") {
+        return {
+            type: "action",
+            handler: handlerOrConfig,
+            auth: "required", // default
+        };
+    }
+    return {
+        type: "action",
+        handler: handlerOrConfig.handler,
+        auth: handlerOrConfig.auth || "required",
+        permissions: handlerOrConfig.permissions,
+        scopes: handlerOrConfig.scopes,
+    };
+}
+
+/**
+ * HTTP endpoint builders
+ */
+export const http = {
+    get: <Args = unknown, Return = Response>(config: {
+        path: string;
+        handler: HttpHandler<Args, Return>;
+        auth?: AuthMode;
+        permissions?: string[];
+        middleware?: Array<(ctx: HttpCtx, next: () => Promise<Response>) => Promise<Response>>;
+    }): HttpDefinition<Args, Return> => ({
+        type: "http",
+        method: "GET",
+        ...config,
+    }),
+
+    post: <Args = unknown, Return = Response>(config: {
+        path: string;
+        handler: HttpHandler<Args, Return>;
+        auth?: AuthMode;
+        permissions?: string[];
+        middleware?: Array<(ctx: HttpCtx, next: () => Promise<Response>) => Promise<Response>>;
+    }): HttpDefinition<Args, Return> => ({
+        type: "http",
+        method: "POST",
+        ...config,
+    }),
+
+    put: <Args = unknown, Return = Response>(config: {
+        path: string;
+        handler: HttpHandler<Args, Return>;
+        auth?: AuthMode;
+        permissions?: string[];
+        middleware?: Array<(ctx: HttpCtx, next: () => Promise<Response>) => Promise<Response>>;
+    }): HttpDefinition<Args, Return> => ({
+        type: "http",
+        method: "PUT",
+        ...config,
+    }),
+
+    delete: <Args = unknown, Return = Response>(config: {
+        path: string;
+        handler: HttpHandler<Args, Return>;
+        auth?: AuthMode;
+        permissions?: string[];
+        middleware?: Array<(ctx: HttpCtx, next: () => Promise<Response>) => Promise<Response>>;
+    }): HttpDefinition<Args, Return> => ({
+        type: "http",
+        method: "DELETE",
+        ...config,
+    }),
+
+    patch: <Args = unknown, Return = Response>(config: {
+        path: string;
+        handler: HttpHandler<Args, Return>;
+        auth?: AuthMode;
+        permissions?: string[];
+        middleware?: Array<(ctx: HttpCtx, next: () => Promise<Response>) => Promise<Response>>;
+    }): HttpDefinition<Args, Return> => ({
+        type: "http",
+        method: "PATCH",
+        ...config,
+    }),
+
+    head: <Args = unknown, Return = Response>(config: {
+        path: string;
+        handler: HttpHandler<Args, Return>;
+        auth?: AuthMode;
+        permissions?: string[];
+        middleware?: Array<(ctx: HttpCtx, next: () => Promise<Response>) => Promise<Response>>;
+    }): HttpDefinition<Args, Return> => ({
+        type: "http",
+        method: "HEAD",
+        ...config,
+    }),
+
+    options: <Args = unknown, Return = Response>(config: {
+        path: string;
+        handler: HttpHandler<Args, Return>;
+        auth?: AuthMode;
+        permissions?: string[];
+        middleware?: Array<(ctx: HttpCtx, next: () => Promise<Response>) => Promise<Response>>;
+    }): HttpDefinition<Args, Return> => ({
+        type: "http",
+        method: "OPTIONS",
+        ...config,
+    }),
+};
+
+/**
+ * Webhook builder
+ */
+export function webhook<Event = unknown, Return = unknown>(config: {
+    path: string;
+    handler: WebhookHandler<Event, Return>;
+    eventSchema?: z.ZodType<Event>;
+    guards?: WebhookGuard[];
+    auth?: AuthMode;
+    method?: HttpMethod;
+}): WebhookDefinition<Event, Return> {
+    return {
+        type: "webhook",
+        method: config.method ?? "POST",
+        path: config.path,
+        handler: config.handler,
+        eventSchema: config.eventSchema,
+        guards: config.guards ?? [],
+        auth: config.auth ?? "public", // Webhooks are typically public with guard verification
+    };
+}
+
+/**
+ * Type guards
+ */
+export function isHttpDefinition(value: any): value is HttpDefinition {
+    return value && typeof value === "object" && value.type === "http";
+}
+
+export function isWebhookDefinition(value: any): value is WebhookDefinition {
+    return value && typeof value === "object" && value.type === "webhook";
+}
+`;
+    }
+    generateIndexExport() {
+        return `// This file is auto-generated by Archlast CLI
+// Do not edit manually
+
+export { api } from './api';
+export type { Api } from './api';
+`;
+    }
+    /**
+     * Generate CRUD handlers for all collections in the schema
+     * Creates _generated/crud/ directory with individual collection files
+     */
+    async generateCrudHandlers(generatedDir) {
+        const crudDir = path.join(generatedDir, "crud");
+        // Ensure crud directory exists
+        if (!fs.existsSync(crudDir)) {
+            fs.mkdirSync(crudDir, { recursive: true });
+        }
+        // Get schema tables
+        const { dataModel, inputTypes } = await this.generateDataModelFromSchema();
+        // Extract table names from the DataModel type
+        const tables = this.extractTableNames(dataModel);
+        if (tables.length === 0) {
+            console.log("  No tables found for CRUD generation");
+            return;
+        }
+        console.log(`  Generating CRUD handlers for ${tables.length} collections`);
+        // Generate individual collection files
+        for (const tableName of tables) {
+            const handlerCode = this.generateCrudHandlerForTable(tableName);
+            const filePath = path.join(crudDir, `${tableName}.ts`);
+            fs.writeFileSync(filePath, handlerCode, "utf-8");
+        }
+        // Generate index.ts that re-exports all handlers
+        const indexCode = this.generateCrudIndex(tables);
+        const indexPath = path.join(crudDir, "index.ts");
+        fs.writeFileSync(indexPath, indexCode, "utf-8");
+        console.log(`  CRUD handlers generated in _generated/crud/`);
+    }
+    /**
+     * Extract table names from the DataModel type string
+     */
+    extractTableNames(dataModel) {
+        // Match table names from DataModel type definition
+        // Pattern: `  tableName: {` or `  "tableName": {`
+        const matches = dataModel.matchAll(/(?:\s*)(?:["']?)(\w+)(?:["']?)\s*:\s*{/g);
+        const tables = [];
+        for (const match of matches) {
+            const tableName = match[1];
+            // Skip system fields and type definitions
+            if (tableName !== "_id" &&
+                tableName !== "_collection" &&
+                tableName !== "DataModel" &&
+                tableName !== "export" &&
+                tableName !== "type") {
+                tables.push(tableName);
+            }
+        }
+        return tables;
+    }
+    /**
+     * Generate CRUD handler code for a single table (public for CLI command)
+     */
+    generateCrudHandlerForTable(tableName) {
+        const pascalName = tableName.charAt(0).toUpperCase() + tableName.slice(1);
+        const camelName = tableName;
+        return `// Auto-generated CRUD handlers for "${tableName}"
+// This file is auto-generated by Archlast CLI - do not edit manually
+
+import { http } from "../server";
+import type { DataModel } from "../server";
+
+const collection = "${tableName}" as const;
+
+// Type for the collection document
+type ${pascalName}Doc = DataModel["${tableName}"];
+// Type for creating a document (excludes auto-generated fields)
+type ${pascalName}Create = Omit<${pascalName}Doc, "_id" | "_collection">;
+// Type for updating a document (all fields optional)
+type ${pascalName}Update = Partial<${pascalName}Create>;
+
+/**
+ * GET /${tableName}
+ * List all ${tableName} records with optional pagination
+ */
+export const list${pascalName} = http.get({
+    path: "/${tableName}",
+    auth: "public",
+    handler: async (ctx) => {
+        // Query params are already parsed into ctx.req.query
+        const limitStr = ctx.req.query.limit;
+        const offsetStr = ctx.req.query.offset;
+        const limit = limitStr ? Number(limitStr) : 50;
+        const offset = offsetStr ? Number(offsetStr) : 0;
+
+        // Use .take() and .skip() for pagination
+        const result = await ctx.db.query(collection)
+            .take(limit)
+            .skip(offset)
+            .findMany();
+
+        return result;
+    },
+});
+
+/**
+ * GET /${tableName}/:id
+ * Get a single ${tableName} record by ID
+ */
+export const get${pascalName} = http.get({
+    path: "/${tableName}/:id",
+    auth: "public",
+    handler: async (ctx) => {
+        // Path params are available in ctx.req.params
+        const id = ctx.req.params.id;
+        const result = await ctx.db.get(collection, id);
+
+        if (!result) {
+            return { error: "${tableName} not found" };
+        }
+
+        return result;
+    },
+});
+
+/**
+ * POST /${tableName}
+ * Create a new ${tableName} record
+ */
+export const create${pascalName} = http.post({
+    path: "/${tableName}",
+    auth: "public",
+    handler: async (ctx) => {
+        // Parse JSON body from the request with proper type
+        const data = await ctx.req.json<${pascalName}Create>();
+
+        const result = await ctx.db.insert(collection, data);
+
+        return result;
+    },
+});
+
+/**
+ * PATCH /${tableName}/:id
+ * Update a ${tableName} record
+ */
+export const update${pascalName} = http.patch({
+    path: "/${tableName}/:id",
+    auth: "public",
+    handler: async (ctx) => {
+        const id = ctx.req.params.id;
+        const data = await ctx.req.json<${pascalName}Update>();
+
+        const existing = await ctx.db.get(collection, id);
+        if (!existing) {
+            return { error: "${tableName} not found" };
+        }
+
+        const result = await ctx.db.update(collection, id, data);
+        return result;
+    },
+});
+
+/**
+ * DELETE /${tableName}/:id
+ * Delete a ${tableName} record
+ */
+export const delete${pascalName} = http.delete({
+    path: "/${tableName}/:id",
+    auth: "public",
+    handler: async (ctx) => {
+        const id = ctx.req.params.id;
+
+        const existing = await ctx.db.get(collection, id);
+        if (!existing) {
+            return { error: "${tableName} not found" };
+        }
+
+        await ctx.db.delete(collection, id);
+        return { success: true };
+    },
+});
+`;
+    }
+    /**
+     * Generate the index.ts file for CRUD handlers
+     */
+    generateCrudIndex(tables) {
+        const exports = tables.map(tableName => {
+            const pascalName = tableName.charAt(0).toUpperCase() + tableName.slice(1);
+            return `export * from "./${tableName}";`;
+        }).join("\n");
+        return `// Auto-generated CRUD exports
+// This file is auto-generated by Archlast CLI - do not edit manually
+
+${exports}
+
+// Re-export all handlers as a grouped object
+import * as tasksHandlers from "./tasks";
+import * as usersHandlers from "./users";
+
+// Add more collections as needed...
+`;
+    }
+}