@vertz/compiler 0.2.12 → 0.2.14

package/dist/index.js

@@ -169,7 +169,11 @@ function isFromImport(identifier, moduleSpecifier) {
   const importInfo = findImportForIdentifier(identifier);
   if (!importInfo)
     return false;
-  return importInfo.importDecl.getModuleSpecifierValue() === moduleSpecifier;
+  const actual = importInfo.importDecl.getModuleSpecifierValue();
+  if (actual === moduleSpecifier)
+    return true;
+  const metaEquivalent = moduleSpecifier.replace(/^@vertz\//, "vertz/");
+  return actual === metaEquivalent;
 }
 function findImportForIdentifier(identifier) {
   const sourceFile = identifier.getSourceFile();
@@ -355,6 +359,104 @@ class AppAnalyzer extends BaseAnalyzer {
     return result;
   }
 }
+// src/analyzers/database-analyzer.ts
+import { SyntaxKind as SyntaxKind3 } from "ts-morph";
+class DatabaseAnalyzer extends BaseAnalyzer {
+  async analyze() {
+    const databases = [];
+    for (const file of this.project.getSourceFiles()) {
+      const calls = this.findCreateDbCalls(file);
+      for (const call of calls) {
+        const db = this.extractDatabase(call);
+        if (db)
+          databases.push(db);
+      }
+    }
+    return { databases };
+  }
+  findCreateDbCalls(file) {
+    const validCalls = [];
+    for (const call of file.getDescendantsOfKind(SyntaxKind3.CallExpression)) {
+      const expr = call.getExpression();
+      if (expr.isKind(SyntaxKind3.Identifier)) {
+        if (isFromImport(expr, "@vertz/db")) {
+          validCalls.push(call);
+        }
+        continue;
+      }
+      if (expr.isKind(SyntaxKind3.PropertyAccessExpression)) {
+        const propName = expr.getName();
+        if (propName !== "createDb")
+          continue;
+        const obj = expr.getExpression();
+        if (!obj.isKind(SyntaxKind3.Identifier))
+          continue;
+        const sourceFile = obj.getSourceFile();
+        const importDecl = sourceFile.getImportDeclarations().find((d) => d.getModuleSpecifierValue() === "@vertz/db" && d.getNamespaceImport()?.getText() === obj.getText());
+        if (importDecl) {
+          validCalls.push(call);
+        }
+      }
+    }
+    return validCalls;
+  }
+  extractDatabase(call) {
+    const loc = getSourceLocation(call);
+    const config = extractObjectLiteral(call, 0);
+    if (!config)
+      return null;
+    const modelsValue = getPropertyValue(config, "models");
+    if (!modelsValue)
+      return null;
+    const modelsObj = this.resolveObjectLiteral(modelsValue);
+    if (!modelsObj)
+      return null;
+    const modelKeys = this.extractModelKeys(modelsObj, loc);
+    return { modelKeys, ...loc };
+  }
+  resolveObjectLiteral(expr) {
+    if (expr.isKind(SyntaxKind3.ObjectLiteralExpression))
+      return expr;
+    if (expr.isKind(SyntaxKind3.Identifier)) {
+      const defs = expr.getDefinitionNodes();
+      for (const def of defs) {
+        if (def.isKind(SyntaxKind3.VariableDeclaration)) {
+          const init = def.getInitializer();
+          if (init?.isKind(SyntaxKind3.ObjectLiteralExpression))
+            return init;
+        }
+      }
+    }
+    return null;
+  }
+  extractModelKeys(obj, loc) {
+    const keys = [];
+    for (const prop of obj.getProperties()) {
+      if (prop.isKind(SyntaxKind3.PropertyAssignment)) {
+        if (prop.getNameNode().isKind(SyntaxKind3.ComputedPropertyName)) {
+          this.addDiagnostic({
+            severity: "warning",
+            code: "ENTITY_MODEL_NOT_REGISTERED",
+            message: "createDb() models object contains a computed property name. " + "Entity-model registration check may be incomplete — " + "computed keys cannot be statically resolved.",
+            ...loc
+          });
+        } else {
+          keys.push(prop.getName());
+        }
+      } else if (prop.isKind(SyntaxKind3.ShorthandPropertyAssignment)) {
+        keys.push(prop.getName());
+      } else if (prop.isKind(SyntaxKind3.SpreadAssignment)) {
+        this.addDiagnostic({
+          severity: "warning",
+          code: "ENTITY_MODEL_NOT_REGISTERED",
+          message: "createDb() models object contains a spread assignment. " + "Entity-model registration check may be incomplete — " + "spread properties cannot be statically resolved.",
+          ...loc
+        });
+      }
+    }
+    return keys;
+  }
+}
 // src/analyzers/dependency-graph-analyzer.ts
 class DependencyGraphAnalyzer extends BaseAnalyzer {
   input = { modules: [], middleware: [] };
@@ -603,1148 +705,1234 @@ class DependencyGraphAnalyzer extends BaseAnalyzer {
     }
   }
 }
-// src/analyzers/env-analyzer.ts
+// src/analyzers/entity-analyzer.ts
 import { SyntaxKind as SyntaxKind4 } from "ts-morph";
+var ENTITY_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+var CRUD_OPS = ["list", "get", "create", "update", "delete"];
 
-// src/analyzers/schema-analyzer.ts
-import { SyntaxKind as SyntaxKind3 } from "ts-morph";
-class SchemaAnalyzer extends BaseAnalyzer {
-  async analyze() {
-    const schemas = [];
-    for (const file of this.project.getSourceFiles()) {
-      if (!isSchemaFile(file))
-        continue;
-      for (const exportSymbol of file.getExportSymbols()) {
-        const declarations = exportSymbol.getDeclarations();
-        for (const decl of declarations) {
-          if (!decl.isKind(SyntaxKind3.VariableDeclaration))
-            continue;
-          const initializer = decl.getInitializer();
-          if (!initializer)
-            continue;
-          if (!isSchemaExpression(file, initializer))
-            continue;
-          const name = exportSymbol.getName();
-          const loc = getSourceLocation(decl);
-          const id = extractSchemaId(initializer);
-          schemas.push({
-            name,
-            ...loc,
-            id: id ?? undefined,
-            moduleName: "",
-            namingConvention: parseSchemaName(name),
-            isNamed: id !== null
-          });
-        }
-      }
-    }
-    return { schemas };
-  }
-}
-var VALID_OPERATIONS = ["create", "read", "update", "list", "delete"];
-var VALID_PARTS = ["Body", "Response", "Query", "Params", "Headers"];
-function parseSchemaName(name) {
-  for (const op of VALID_OPERATIONS) {
-    if (!name.startsWith(op))
-      continue;
-    const rest = name.slice(op.length);
-    if (rest.length === 0)
-      continue;
-    for (const part of VALID_PARTS) {
-      if (!rest.endsWith(part))
-        continue;
-      const entity = rest.slice(0, -part.length);
-      if (entity.length === 0)
-        continue;
-      const firstChar = entity.at(0);
-      if (!firstChar || firstChar !== firstChar.toUpperCase())
-        continue;
-      return { operation: op, entity, part };
-    }
-  }
-  return {};
-}
-function isSchemaExpression(_file, expr) {
-  const root = findRootIdentifier(expr);
-  if (!root)
-    return false;
-  return isFromImport(root, "@vertz/schema");
-}
-function extractSchemaId(expr) {
-  let current = expr;
-  while (current.isKind(SyntaxKind3.CallExpression)) {
-    const access = current.getExpression();
-    if (access.isKind(SyntaxKind3.PropertyAccessExpression) && access.getName() === "id") {
-      const args = current.getArguments();
-      if (args.length === 1) {
-        const firstArg = args.at(0);
-        const value = firstArg ? getStringValue(firstArg) : null;
-        if (value !== null)
-          return value;
-      }
-    }
-    if (access.isKind(SyntaxKind3.PropertyAccessExpression)) {
-      current = access.getExpression();
-    } else {
-      break;
+class EntityAnalyzer extends BaseAnalyzer {
+  debug(msg) {
+    if (process.env["VERTZ_DEBUG"]?.includes("entities")) {
+      console.log(`[entity-analyzer] ${msg}`);
     }
   }
-  return null;
-}
-function isSchemaFile(file) {
-  return file.getImportDeclarations().some((decl) => decl.getModuleSpecifierValue() === "@vertz/schema");
-}
-function createNamedSchemaRef(schemaName, sourceFile) {
-  return { kind: "named", schemaName, sourceFile };
-}
-function createInlineSchemaRef(sourceFile) {
-  return { kind: "inline", sourceFile };
-}
-function findRootIdentifier(expr) {
-  if (expr.isKind(SyntaxKind3.CallExpression)) {
-    return findRootIdentifier(expr.getExpression());
-  }
-  if (expr.isKind(SyntaxKind3.PropertyAccessExpression)) {
-    return findRootIdentifier(expr.getExpression());
-  }
-  if (expr.isKind(SyntaxKind3.Identifier)) {
-    return expr;
-  }
-  return null;
-}
-
-// src/analyzers/env-analyzer.ts
-class EnvAnalyzer extends BaseAnalyzer {
   async analyze() {
-    let env;
-    for (const file of this.project.getSourceFiles()) {
-      const calls = findCallExpressions(file, "vertz", "env");
+    const entities = [];
+    const seenNames = new Map;
+    const modelExprs = new Map;
+    const files = this.project.getSourceFiles();
+    this.debug(`Scanning ${files.length} source files...`);
+    for (const file of files) {
+      const calls = this.findEntityCalls(file);
       for (const call of calls) {
-        const obj = extractObjectLiteral(call, 0);
-        if (!obj)
+        const result = this.extractEntity(file, call);
+        if (!result)
           continue;
-        const loc = getSourceLocation(call);
-        if (env) {
-          this.addDiagnostic(createDiagnosticFromLocation(loc, {
+        const { entity, modelExpr } = result;
+        const existing = seenNames.get(entity.name);
+        if (existing) {
+          this.addDiagnostic({
+            code: "ENTITY_DUPLICATE_NAME",
             severity: "error",
-            code: "VERTZ_ENV_DUPLICATE",
-            message: "Multiple vertz.env() calls found. Only one is allowed."
-          }));
+            message: `Entity "${entity.name}" is already defined at ${existing.sourceFile}:${existing.sourceLine}`,
+            ...getSourceLocation(call)
+          });
           continue;
         }
-        const loadExpr = getPropertyValue(obj, "load");
-        const loadFiles = loadExpr ? getArrayElements(loadExpr).map((e) => getStringValue(e)).filter((v) => v !== null) : [];
-        const schemaExpr = getPropertyValue(obj, "schema");
-        let schema;
-        if (schemaExpr?.isKind(SyntaxKind4.Identifier)) {
-          schema = createNamedSchemaRef(schemaExpr.getText(), file.getFilePath());
+        seenNames.set(entity.name, entity);
+        entities.push(entity);
+        if (modelExpr)
+          modelExprs.set(entity.name, modelExpr);
+        this.debug(`Detected entity: "${entity.name}" at ${entity.sourceFile}:${entity.sourceLine}`);
+        this.debug(`  model: ${entity.modelRef.variableName} (resolved: ${entity.modelRef.schemaRefs.resolved ? "✅" : "❌"})`);
+        const accessStatus = CRUD_OPS.map((op) => {
+          const kind = entity.access[op];
+          return `${op} ${kind === "false" ? "✗" : "✓"}`;
+        }).join(", ");
+        this.debug(`  access: ${accessStatus}`);
+        if (entity.hooks.before.length > 0 || entity.hooks.after.length > 0) {
+          this.debug(`  hooks: before[${entity.hooks.before.join(",")}], after[${entity.hooks.after.join(",")}]`);
+        }
+        if (entity.actions.length > 0) {
+          this.debug(`  actions: ${entity.actions.map((a) => a.name).join(", ")}`);
         }
-        env = {
-          ...loc,
-          loadFiles,
-          schema,
-          variables: []
-        };
       }
     }
-    return { env };
-  }
-}
-// src/analyzers/middleware-analyzer.ts
-import { SyntaxKind as SyntaxKind6 } from "ts-morph";
-
-// src/analyzers/service-analyzer.ts
-import { SyntaxKind as SyntaxKind5 } from "ts-morph";
-class ServiceAnalyzer extends BaseAnalyzer {
-  async analyze() {
-    return { services: [] };
+    this.resolveRelationEntities(entities, modelExprs);
+    return { entities };
   }
-  async analyzeForModule(moduleDefVarName, moduleName) {
-    const services = [];
-    for (const file of this.project.getSourceFiles()) {
-      const calls = findMethodCallsOnVariable(file, moduleDefVarName, "service");
-      for (const call of calls) {
-        const name = getVariableNameForCall(call);
-        if (!name)
+  findEntityCalls(file) {
+    const validCalls = [];
+    for (const call of file.getDescendantsOfKind(SyntaxKind4.CallExpression)) {
+      const expr = call.getExpression();
+      if (expr.isKind(SyntaxKind4.Identifier)) {
+        const isValid = isFromImport(expr, "@vertz/server");
+        if (!isValid && expr.getText() === "entity") {
+          this.addDiagnostic({
+            code: "ENTITY_UNRESOLVED_IMPORT",
+            severity: "error",
+            message: "entity() call does not resolve to @vertz/server",
+            ...getSourceLocation(call)
+          });
           continue;
-        const obj = extractObjectLiteral(call, 0);
-        const inject = obj ? parseInjectFromObj(obj) : [];
-        const methods = obj ? parseMethodsFromObj(obj) : [];
-        const loc = getSourceLocation(call);
-        services.push({
-          name,
-          moduleName,
-          ...loc,
-          inject,
-          methods
-        });
+        }
+        if (isValid) {
+          validCalls.push(call);
+        }
+        continue;
       }
-    }
-    return services;
-  }
-}
-function parseInjectFromObj(obj) {
-  const injectExpr = getPropertyValue(obj, "inject");
-  if (!injectExpr?.isKind(SyntaxKind5.ObjectLiteralExpression))
-    return [];
-  return parseInjectRefs(injectExpr);
-}
-function parseMethodsFromObj(obj) {
-  const methodsExpr = getPropertyValue(obj, "methods");
-  if (!methodsExpr)
-    return [];
-  return extractMethodSignatures(methodsExpr);
-}
-function parseInjectRefs(obj) {
-  return getProperties(obj).map(({ name, value }) => {
-    const resolvedToken = value.isKind(SyntaxKind5.Identifier) ? value.getText() : name;
-    return { localName: name, resolvedToken };
-  });
-}
-function extractMethodSignatures(expr) {
-  if (!expr.isKind(SyntaxKind5.ArrowFunction) && !expr.isKind(SyntaxKind5.FunctionExpression)) {
-    return [];
+      if (expr.isKind(SyntaxKind4.PropertyAccessExpression)) {
+        const propName = expr.getName();
+        if (propName !== "entity")
+          continue;
+        const obj = expr.getExpression();
+        if (!obj.isKind(SyntaxKind4.Identifier))
+          continue;
+        const sourceFile = obj.getSourceFile();
+        const importDecl = sourceFile.getImportDeclarations().find((d) => d.getModuleSpecifierValue() === "@vertz/server" && d.getNamespaceImport()?.getText() === obj.getText());
+        if (importDecl) {
+          validCalls.push(call);
+        }
+      }
+    }
+    return validCalls;
   }
-  const body = expr.getBody();
-  let returnObj = null;
-  if (body.isKind(SyntaxKind5.ObjectLiteralExpression)) {
-    returnObj = body;
-  } else if (body.isKind(SyntaxKind5.ParenthesizedExpression)) {
-    const inner = body.getExpression();
-    if (inner.isKind(SyntaxKind5.ObjectLiteralExpression)) {
-      returnObj = inner;
+  extractEntity(_file, call) {
+    const args = call.getArguments();
+    const loc = getSourceLocation(call);
+    if (args.length < 2) {
+      this.addDiagnostic({
+        code: "ENTITY_MISSING_ARGS",
+        severity: "error",
+        message: "entity() requires two arguments: name and config",
+        ...loc
+      });
+      return null;
     }
-  } else if (body.isKind(SyntaxKind5.Block)) {
-    const returnStmt = body.getStatements().find((s) => s.isKind(SyntaxKind5.ReturnStatement));
-    const retExpr = returnStmt?.asKind(SyntaxKind5.ReturnStatement)?.getExpression();
-    if (retExpr?.isKind(SyntaxKind5.ObjectLiteralExpression)) {
-      returnObj = retExpr;
+    const name = getStringValue(args[0]);
+    if (name === null) {
+      this.addDiagnostic({
+        code: "ENTITY_NON_LITERAL_NAME",
+        severity: "error",
+        message: "entity() name must be a string literal",
+        ...loc
+      });
+      return null;
+    }
+    if (!ENTITY_NAME_PATTERN.test(name)) {
+      this.addDiagnostic({
+        code: "ENTITY_INVALID_NAME",
+        severity: "error",
+        message: `Entity name must match /^[a-z][a-z0-9-]*$/. Got: "${name}"`,
+        ...loc
+      });
+      return null;
+    }
+    const configObj = extractObjectLiteral(call, 1);
+    if (!configObj) {
+      this.addDiagnostic({
+        code: "ENTITY_CONFIG_NOT_OBJECT",
+        severity: "warning",
+        message: "entity() config must be an object literal for static analysis",
+        ...loc
+      });
+      return null;
     }
+    const modelRef = this.extractModelRef(configObj, loc);
+    if (!modelRef)
+      return null;
+    const access = this.extractAccess(configObj);
+    const hooks = this.extractHooks(configObj);
+    const actions = this.extractActions(configObj);
+    const modelExpr = getPropertyValue(configObj, "model");
+    const relations = this.extractRelations(configObj, modelExpr ?? undefined);
+    for (const action of actions) {
+      if (CRUD_OPS.includes(action.name)) {
+        this.addDiagnostic({
+          code: "ENTITY_ACTION_NAME_COLLISION",
+          severity: "error",
+          message: `Custom action "${action.name}" collides with built-in CRUD operation`,
+          ...action
+        });
+      }
+    }
+    for (const customOp of Object.keys(access.custom)) {
+      if (!actions.some((a) => a.name === customOp)) {
+        this.addDiagnostic({
+          code: "ENTITY_UNKNOWN_ACCESS_OP",
+          severity: "warning",
+          message: `Unknown access operation "${customOp}" — not a CRUD op or custom action`,
+          ...loc
+        });
+      }
+    }
+    return {
+      entity: { name, modelRef, access, hooks, actions, relations, ...loc },
+      modelExpr: modelExpr ?? undefined
+    };
   }
-  if (!returnObj)
-    return [];
-  const methods = [];
-  for (const prop of returnObj.getProperties()) {
-    if (!prop.isKind(SyntaxKind5.PropertyAssignment))
-      continue;
-    const methodName = prop.getName();
-    const init = prop.getInitializer();
-    if (!init)
-      continue;
-    const params = extractFunctionParams(init);
-    const returnType = inferReturnType(init);
-    methods.push({
-      name: methodName,
-      parameters: params,
-      returnType
-    });
+  extractModelRef(configObj, loc) {
+    const modelExpr = getPropertyValue(configObj, "model");
+    if (!modelExpr) {
+      this.addDiagnostic({
+        code: "ENTITY_MISSING_MODEL",
+        severity: "error",
+        message: "entity() requires a model property",
+        ...loc
+      });
+      return null;
+    }
+    const variableName = modelExpr.isKind(SyntaxKind4.Identifier) ? modelExpr.getText() : modelExpr.getText();
+    let importSource;
+    if (modelExpr.isKind(SyntaxKind4.Identifier)) {
+      const importInfo = this.findImportForIdentifier(modelExpr);
+      if (importInfo) {
+        importSource = importInfo.importDecl.getModuleSpecifierValue();
+      }
+    }
+    const schemaRefs = this.resolveModelSchemas(modelExpr);
+    return { variableName, importSource, schemaRefs };
   }
-  return methods;
-}
-function extractFunctionParams(expr) {
-  if (!expr.isKind(SyntaxKind5.ArrowFunction) && !expr.isKind(SyntaxKind5.FunctionExpression)) {
-    return [];
+  findImportForIdentifier(identifier) {
+    const sourceFile = identifier.getSourceFile();
+    const name = identifier.getText();
+    for (const importDecl of sourceFile.getImportDeclarations()) {
+      for (const specifier of importDecl.getNamedImports()) {
+        const localName = specifier.getAliasNode()?.getText() ?? specifier.getName();
+        if (localName === name) {
+          return { importDecl, originalName: specifier.getName() };
+        }
+      }
+      const nsImport = importDecl.getNamespaceImport();
+      if (nsImport && nsImport.getText() === name) {
+        return { importDecl, originalName: "*" };
+      }
+    }
+    return null;
   }
-  return expr.getParameters().map((p) => ({
-    name: p.getName(),
-    type: p.getType().getText(p)
-  }));
-}
-function inferReturnType(expr) {
-  if (expr.isKind(SyntaxKind5.ArrowFunction) || expr.isKind(SyntaxKind5.FunctionExpression)) {
-    const retType = expr.getReturnType();
-    return retType.getText(expr);
+  resolveModelSchemas(modelExpr) {
+    try {
+      const modelType = modelExpr.getType();
+      const schemasProp = modelType.getProperty("schemas");
+      if (!schemasProp)
+        return { resolved: false };
+      const schemasType = schemasProp.getTypeAtLocation(modelExpr);
+      const response = this.extractSchemaType(schemasType, "response", modelExpr);
+      const createInput = this.extractSchemaType(schemasType, "createInput", modelExpr);
+      const updateInput = this.extractSchemaType(schemasType, "updateInput", modelExpr);
+      return {
+        response,
+        createInput,
+        updateInput,
+        resolved: response !== undefined || createInput !== undefined || updateInput !== undefined
+      };
+    } catch {
+      return { resolved: false };
+    }
   }
-  return "unknown";
-}
-
-// src/analyzers/middleware-analyzer.ts
-class MiddlewareAnalyzer extends BaseAnalyzer {
-  async analyze() {
-    const middleware = [];
-    for (const file of this.project.getSourceFiles()) {
-      const calls = findCallExpressions(file, "vertz", "middleware");
-      for (const call of calls) {
-        const obj = extractObjectLiteral(call, 0);
-        if (!obj) {
-          const callLoc = getSourceLocation(call);
-          this.addDiagnostic(createDiagnosticFromLocation(callLoc, {
-            severity: "warning",
-            code: "VERTZ_MW_NON_OBJECT_CONFIG",
-            message: "Middleware config must be an object literal for static analysis.",
-            suggestion: "Pass an inline object literal to vertz.middleware()."
-          }));
-          continue;
-        }
-        const loc = getSourceLocation(call);
-        const nameExpr = getPropertyValue(obj, "name");
-        if (!nameExpr) {
-          this.addDiagnostic(createDiagnosticFromLocation(loc, {
-            severity: "error",
-            code: "VERTZ_MW_MISSING_NAME",
-            message: "Middleware must have a 'name' property.",
-            suggestion: "Add a 'name' property to the middleware config."
-          }));
-          continue;
-        }
-        const name = getStringValue(nameExpr);
-        if (!name) {
-          this.addDiagnostic(createDiagnosticFromLocation(loc, {
-            severity: "warning",
-            code: "VERTZ_MW_DYNAMIC_NAME",
-            message: "Middleware name should be a string literal for static analysis.",
-            suggestion: "Use a string literal for the middleware name."
-          }));
-          continue;
+  extractSchemaType(parentType, propertyName, location) {
+    const prop = parentType.getProperty(propertyName);
+    if (!prop)
+      return;
+    const propType = prop.getTypeAtLocation(location);
+    const resolvedFields = this.resolveFieldsFromSchemaType(propType, location);
+    const jsonSchema = this.buildJsonSchema(resolvedFields);
+    return {
+      kind: "inline",
+      sourceFile: location.getSourceFile().getFilePath(),
+      jsonSchema,
+      resolvedFields
+    };
+  }
+  buildJsonSchema(resolvedFields) {
+    if (!resolvedFields || resolvedFields.length === 0) {
+      return {};
+    }
+    const properties = {};
+    const required = [];
+    for (const field of resolvedFields) {
+      const fieldSchema = this.tsTypeToJsonSchema(field.tsType);
+      properties[field.name] = fieldSchema;
+      if (!field.optional) {
+        required.push(field.name);
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {}
+    };
+  }
+  tsTypeToJsonSchema(tsType) {
+    switch (tsType) {
+      case "string":
+        return { type: "string" };
+      case "number":
+        return { type: "number" };
+      case "boolean":
+        return { type: "boolean" };
+      case "date":
+        return { type: "string", format: "date-time" };
+      case "unknown":
+      default:
+        return {};
+    }
+  }
+  resolveFieldsFromSchemaType(schemaType, location) {
+    try {
+      const parseProp = schemaType.getProperty("parse");
+      if (!parseProp)
+        return;
+      const parseType = parseProp.getTypeAtLocation(location);
+      const callSignatures = parseType.getCallSignatures();
+      if (callSignatures.length === 0)
+        return;
+      const returnType = callSignatures[0]?.getReturnType();
+      if (!returnType)
+        return;
+      const dataType = this.unwrapResultType(returnType, location);
+      if (!dataType)
+        return;
+      const properties = dataType.getProperties();
+      if (properties.length === 0)
+        return;
+      const fields = [];
+      for (const fieldProp of properties) {
+        const name = fieldProp.getName();
+        const fieldType = fieldProp.getTypeAtLocation(location);
+        const optional = fieldProp.isOptional();
+        const tsType = this.mapTsType(fieldType);
+        fields.push({ name, tsType, optional });
+      }
+      return fields;
+    } catch {
+      return;
+    }
+  }
+  unwrapResultType(type, location) {
+    if (type.isUnion()) {
+      for (const member of type.getUnionTypes()) {
+        const dataProp2 = member.getProperty("data");
+        if (dataProp2) {
+          return dataProp2.getTypeAtLocation(location);
         }
-        const handlerExpr = getPropertyValue(obj, "handler");
-        if (!handlerExpr) {
-          this.addDiagnostic(createDiagnosticFromLocation(loc, {
+      }
+      return;
+    }
+    const dataProp = type.getProperty("data");
+    if (dataProp) {
+      return dataProp.getTypeAtLocation(location);
+    }
+    return type;
+  }
+  mapTsType(type) {
+    const typeText = type.getText();
+    if (type.isUnion()) {
+      const nonUndefined = type.getUnionTypes().filter((t) => !t.isUndefined());
+      if (nonUndefined.length === 1 && nonUndefined[0]) {
+        return this.mapTsType(nonUndefined[0]);
+      }
+    }
+    if (type.isString() || type.isStringLiteral())
+      return "string";
+    if (type.isNumber() || type.isNumberLiteral())
+      return "number";
+    if (type.isBoolean() || type.isBooleanLiteral())
+      return "boolean";
+    if (typeText === "Date")
+      return "date";
+    return "unknown";
+  }
+  extractAccess(configObj) {
+    const defaults = {
+      list: "none",
+      get: "none",
+      create: "none",
+      update: "none",
+      delete: "none",
+      custom: {}
+    };
+    const accessExpr = getPropertyValue(configObj, "access");
+    if (!accessExpr || !accessExpr.isKind(SyntaxKind4.ObjectLiteralExpression))
+      return defaults;
+    const result = { ...defaults };
+    const knownOps = new Set([...CRUD_OPS]);
+    for (const { name, value } of getProperties(accessExpr)) {
+      const kind = this.classifyAccessRule(value);
+      if (knownOps.has(name)) {
+        result[name] = kind;
+      } else {
+        result.custom[name] = kind;
+      }
+    }
+    return result;
+  }
+  classifyAccessRule(expr) {
+    const boolVal = getBooleanValue(expr);
+    if (boolVal === false)
+      return "false";
+    if (boolVal === true)
+      return "none";
+    return "function";
+  }
+  extractHooks(configObj) {
+    const hooks = { before: [], after: [] };
+    const beforeExpr = getPropertyValue(configObj, "before");
+    if (beforeExpr?.isKind(SyntaxKind4.ObjectLiteralExpression)) {
+      for (const { name } of getProperties(beforeExpr)) {
+        if (name === "create" || name === "update")
+          hooks.before.push(name);
+      }
+    }
+    const afterExpr = getPropertyValue(configObj, "after");
+    if (afterExpr?.isKind(SyntaxKind4.ObjectLiteralExpression)) {
+      for (const { name } of getProperties(afterExpr)) {
+        if (name === "create" || name === "update" || name === "delete")
+          hooks.after.push(name);
+      }
+    }
+    return hooks;
+  }
+  extractActions(configObj) {
+    const actionsExpr = getPropertyValue(configObj, "actions");
+    if (!actionsExpr?.isKind(SyntaxKind4.ObjectLiteralExpression))
+      return [];
+    return getProperties(actionsExpr).map(({ name, value }) => {
+      const actionObj = value.isKind(SyntaxKind4.ObjectLiteralExpression) ? value : null;
+      const loc = getSourceLocation(value);
+      const bodyExpr = actionObj ? getPropertyValue(actionObj, "body") : null;
+      const responseExpr = actionObj ? getPropertyValue(actionObj, "response") : null;
+      if (!bodyExpr && !responseExpr) {
+        this.addDiagnostic({
+          code: "ENTITY_ACTION_MISSING_SCHEMA",
+          severity: "warning",
+          message: `Custom action "${name}" is missing body and response schema`,
+          ...loc
+        });
+      }
+      const body = bodyExpr ? this.resolveSchemaFromExpression(bodyExpr, loc) : undefined;
+      const response = responseExpr ? this.resolveSchemaFromExpression(responseExpr, loc) : undefined;
+      const methodExpr = actionObj ? getPropertyValue(actionObj, "method") : null;
+      let method = "POST";
+      if (methodExpr) {
+        const methodStr = getStringValue(methodExpr);
+        const validMethods = [
+          "GET",
+          "POST",
+          "PUT",
+          "DELETE",
+          "PATCH",
+          "HEAD",
+          "OPTIONS"
+        ];
+        if (methodStr && validMethods.includes(methodStr)) {
+          method = methodStr;
+        } else {
+          this.addDiagnostic({
+            code: "ENTITY_ACTION_INVALID_METHOD",
             severity: "error",
-            code: "VERTZ_MW_MISSING_HANDLER",
-            message: "Middleware must have a 'handler' property.",
-            suggestion: "Add a 'handler' property to the middleware config."
-          }));
-          continue;
+            message: `Custom action "${name}" has invalid method "${methodStr ?? "(non-string)"}" — must be one of GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS`,
+            ...loc
+          });
         }
-        const injectExpr = getPropertyValue(obj, "inject");
-        const inject = injectExpr?.isKind(SyntaxKind6.ObjectLiteralExpression) ? parseInjectRefs(injectExpr) : [];
-        const filePath = file.getFilePath();
-        const headers = this.resolveSchemaRef(obj, "headers", filePath);
-        const params = this.resolveSchemaRef(obj, "params", filePath);
-        const query = this.resolveSchemaRef(obj, "query", filePath);
-        const body = this.resolveSchemaRef(obj, "body", filePath);
-        const requires = this.resolveSchemaRef(obj, "requires", filePath);
-        const provides = this.resolveSchemaRef(obj, "provides", filePath);
-        middleware.push({
-          name,
-          ...loc,
-          inject,
-          headers,
-          params,
-          query,
-          body,
-          requires,
-          provides
-        });
       }
-    }
-    return { middleware };
+      const pathExpr = actionObj ? getPropertyValue(actionObj, "path") : null;
+      const path = pathExpr ? getStringValue(pathExpr) ?? undefined : undefined;
+      const queryExpr = actionObj ? getPropertyValue(actionObj, "query") : null;
+      const queryRef = queryExpr ? this.resolveSchemaFromExpression(queryExpr, loc) : undefined;
+      const paramsExpr = actionObj ? getPropertyValue(actionObj, "params") : null;
+      const paramsRef = paramsExpr ? this.resolveSchemaFromExpression(paramsExpr, loc) : undefined;
+      const headersExpr = actionObj ? getPropertyValue(actionObj, "headers") : null;
+      const headersRef = headersExpr ? this.resolveSchemaFromExpression(headersExpr, loc) : undefined;
+      return {
+        name,
+        method,
+        path,
+        params: paramsRef,
+        query: queryRef,
+        headers: headersRef,
+        body,
+        response,
+        ...loc
+      };
+    });
   }
-  resolveSchemaRef(obj, prop, filePath) {
-    const expr = getPropertyValue(obj, prop);
-    if (!expr)
-      return;
-    if (expr.isKind(SyntaxKind6.Identifier)) {
-      const resolved = resolveIdentifier(expr, this.project);
-      const resolvedPath = resolved ? resolved.sourceFile.getFilePath() : filePath;
-      return createNamedSchemaRef(expr.getText(), resolvedPath);
+  resolveSchemaFromExpression(expr, loc) {
+    if (expr.isKind(SyntaxKind4.Identifier)) {
+      const varName = expr.getText();
+      return { kind: "named", schemaName: varName, sourceFile: loc.sourceFile };
     }
-    if (isSchemaExpression(expr.getSourceFile(), expr)) {
-      return createInlineSchemaRef(filePath);
+    try {
+      const typeText = expr.getType().getText();
+      return { kind: "inline", sourceFile: loc.sourceFile, jsonSchema: { __typeText: typeText } };
+    } catch {
+      return { kind: "inline", sourceFile: loc.sourceFile };
     }
-    return;
   }
-}
-// src/analyzers/module-analyzer.ts
-import { SyntaxKind as SyntaxKind7 } from "ts-morph";
-class ModuleAnalyzer extends BaseAnalyzer {
-  async analyze() {
-    const modules = [];
-    const defVarToIndex = new Map;
-    for (const file of this.project.getSourceFiles()) {
-      const defCalls = findCallExpressions(file, "vertz", "moduleDef");
-      for (const call of defCalls) {
-        const obj = extractObjectLiteral(call, 0);
-        if (!obj)
-          continue;
-        const nameExpr = getPropertyValue(obj, "name");
-        const name = nameExpr ? getStringValue(nameExpr) : null;
-        if (!name) {
-          this.addDiagnostic(createDiagnosticFromLocation(getSourceLocation(call), {
-            severity: "error",
-            code: "VERTZ_MODULE_DYNAMIC_NAME",
-            message: "vertz.moduleDef() requires a static string `name` property."
-          }));
+  extractRelations(configObj, modelExpr) {
+    const relExpr = getPropertyValue(configObj, "relations");
+    if (!relExpr?.isKind(SyntaxKind4.ObjectLiteralExpression))
+      return [];
+    const modelRelTypes = modelExpr ? this.resolveModelRelationTypes(modelExpr) : new Map;
+    return getProperties(relExpr).filter(({ value }) => {
+      const boolVal = getBooleanValue(value);
+      return boolVal !== false;
+    }).map(({ name, value }) => {
+      const boolVal = getBooleanValue(value);
+      const selection = boolVal === true ? "all" : value.isKind(SyntaxKind4.ObjectLiteralExpression) ? getProperties(value).map((p) => p.name) : "all";
+      const relType = modelRelTypes.get(name);
+      return {
+        name,
+        type: relType?.type,
+        entity: relType?.entity,
+        selection
+      };
+    });
+  }
+  resolveModelRelationTypes(modelExpr) {
+    const result = new Map;
+    try {
+      const modelType = modelExpr.getType();
+      const relProp = modelType.getProperty("relations");
+      if (!relProp)
+        return result;
+      const relType = relProp.getTypeAtLocation(modelExpr);
+      for (const prop of relType.getProperties()) {
+        const propName = prop.getName();
+        const propType = prop.getTypeAtLocation(modelExpr);
+        const typeProp = propType.getProperty("_type");
+        if (!typeProp)
           continue;
-        }
-        const varName = getVariableNameForCall(call);
-        const importsExpr = getPropertyValue(obj, "imports");
-        const imports = importsExpr?.isKind(SyntaxKind7.ObjectLiteralExpression) ? parseImports(importsExpr) : [];
-        const optionsExpr = getPropertyValue(obj, "options");
-        let options;
-        if (optionsExpr?.isKind(SyntaxKind7.Identifier)) {
-          options = createNamedSchemaRef(optionsExpr.getText(), file.getFilePath());
-        }
-        const loc = getSourceLocation(call);
-        const idx = modules.length;
-        modules.push({
-          name,
-          ...loc,
-          imports,
-          options,
-          services: [],
-          routers: [],
-          exports: []
-        });
-        if (varName) {
-          defVarToIndex.set(varName, idx);
+        const typeType = typeProp.getTypeAtLocation(modelExpr);
+        if (typeType.isStringLiteral()) {
+          const literal = typeType.getLiteralValue();
+          if (literal === "one" || literal === "many") {
+            result.set(propName, { type: literal });
+          }
         }
       }
-    }
-    for (const file of this.project.getSourceFiles()) {
-      const moduleCalls = findCallExpressions(file, "vertz", "module");
-      for (const call of moduleCalls) {
-        const args = call.getArguments();
-        if (args.length < 2)
-          continue;
-        const defArg = args.at(0);
-        if (!defArg?.isKind(SyntaxKind7.Identifier))
+    } catch {}
+    return result;
+  }
+  resolveRelationEntities(entities, modelExprs) {
+    try {
+      const tableToEntity = new Map;
+      for (const entity of entities) {
+        const modelExpr = modelExprs.get(entity.name);
+        if (!modelExpr)
           continue;
-        const defVarName = defArg.getText();
-        const idx = defVarToIndex.get(defVarName);
-        if (idx === undefined)
+        const modelType = modelExpr.getType();
+        const tableProp = modelType.getProperty("table");
+        if (!tableProp)
           continue;
-        const mod = modules.at(idx);
-        if (!mod)
+        const tableType = tableProp.getTypeAtLocation(modelExpr);
+        const typeText = tableType.getText(modelExpr);
+        tableToEntity.set(typeText, entity.name);
+      }
+      if (tableToEntity.size === 0)
+        return;
+      for (const entity of entities) {
+        const modelExpr = modelExprs.get(entity.name);
+        if (!modelExpr)
           continue;
-        const assemblyObj = extractObjectLiteral(call, 1);
-        if (!assemblyObj)
+        const modelType = modelExpr.getType();
+        const relProp = modelType.getProperty("relations");
+        if (!relProp)
           continue;
-        const exportsExpr = getPropertyValue(assemblyObj, "exports");
-        if (exportsExpr) {
-          mod.exports = extractIdentifierNames(exportsExpr);
+        const relType = relProp.getTypeAtLocation(modelExpr);
+        for (const relation of entity.relations) {
+          if (relation.entity)
+            continue;
+          const prop = relType.getProperty(relation.name);
+          if (!prop)
+            continue;
+          const propType = prop.getTypeAtLocation(modelExpr);
+          const targetProp = propType.getProperty("_target");
+          if (!targetProp)
+            continue;
+          const targetType = targetProp.getTypeAtLocation(modelExpr);
+          const callSigs = targetType.getCallSignatures();
+          if (callSigs.length === 0)
+            continue;
+          const returnType = callSigs[0].getReturnType();
+          const targetTypeText = returnType.getText(modelExpr);
+          const targetEntity = tableToEntity.get(targetTypeText);
+          if (targetEntity) {
+            relation.entity = targetEntity;
+          }
         }
       }
-    }
-    return { modules };
+    } catch {}
   }
 }
-function parseImports(obj) {
-  return getProperties(obj).map(({ name }) => ({
-    localName: name,
-    isEnvImport: false
-  }));
-}
-function extractIdentifierNames(expr) {
-  if (!expr.isKind(SyntaxKind7.ArrayLiteralExpression))
-    return [];
-  return expr.getElements().filter((e) => e.isKind(SyntaxKind7.Identifier)).map((e) => e.getText());
-}
-// src/analyzers/route-analyzer.ts
-import { SyntaxKind as SyntaxKind8 } from "ts-morph";
-var HTTP_METHODS = {
-  get: "GET",
-  post: "POST",
-  put: "PUT",
-  patch: "PATCH",
-  delete: "DELETE",
-  head: "HEAD"
-};
+// src/analyzers/env-analyzer.ts
+import { SyntaxKind as SyntaxKind6 } from "ts-morph";
 
-class RouteAnalyzer extends BaseAnalyzer {
+// src/analyzers/schema-analyzer.ts
+import { SyntaxKind as SyntaxKind5 } from "ts-morph";
+class SchemaAnalyzer extends BaseAnalyzer {
   async analyze() {
-    return { routers: [] };
-  }
-  async analyzeForModules(context) {
-    const routers = [];
-    const knownModuleDefVars = new Set(context.moduleDefVariables.keys());
+    const schemas = [];
     for (const file of this.project.getSourceFiles()) {
-      for (const [moduleDefVar, moduleName] of context.moduleDefVariables) {
-        const routerCalls = findMethodCallsOnVariable(file, moduleDefVar, "router");
-        for (const call of routerCalls) {
-          const varName = getVariableNameForCall(call);
-          if (!varName)
+      if (!isSchemaFile(file))
+        continue;
+      for (const exportSymbol of file.getExportSymbols()) {
+        const declarations = exportSymbol.getDeclarations();
+        for (const decl of declarations) {
+          if (!decl.isKind(SyntaxKind5.VariableDeclaration))
             continue;
-          const obj = extractObjectLiteral(call, 0);
-          const prefixExpr = obj ? getPropertyValue(obj, "prefix") : null;
-          const prefix = prefixExpr ? getStringValue(prefixExpr) ?? "/" : "/";
-          if (!prefixExpr) {
-            this.addDiagnostic(createDiagnosticFromLocation(getSourceLocation(call), {
-              severity: "warning",
-              code: "VERTZ_RT_MISSING_PREFIX",
-              message: "Router should have a 'prefix' property.",
-              suggestion: "Add a 'prefix' property to the router config."
-            }));
-          }
-          const loc = getSourceLocation(call);
-          const injectExpr = obj ? getPropertyValue(obj, "inject") : null;
-          const inject = injectExpr?.isKind(SyntaxKind8.ObjectLiteralExpression) ? parseInjectRefs(injectExpr) : [];
-          const routes = this.extractRoutes(file, varName, prefix, moduleName);
-          routers.push({
-            name: varName,
-            moduleName,
+          const initializer = decl.getInitializer();
+          if (!initializer)
+            continue;
+          if (!isSchemaExpression(file, initializer))
+            continue;
+          const name = exportSymbol.getName();
+          const loc = getSourceLocation(decl);
+          const id = extractSchemaId(initializer);
+          schemas.push({
+            name,
             ...loc,
-            prefix,
-            inject,
-            routes
+            id: id ?? undefined,
+            moduleName: "",
+            namingConvention: parseSchemaName(name),
+            isNamed: id !== null
           });
         }
       }
-      this.detectUnknownRouterCalls(file, knownModuleDefVars);
     }
-    return { routers };
+    return { schemas };
   }
-  detectUnknownRouterCalls(file, knownModuleDefVars) {
-    const allCalls = file.getDescendantsOfKind(SyntaxKind8.CallExpression);
-    for (const call of allCalls) {
-      const expr = call.getExpression();
-      if (!expr.isKind(SyntaxKind8.PropertyAccessExpression))
-        continue;
-      if (expr.getName() !== "router")
-        continue;
-      const obj = expr.getExpression();
-      if (!obj.isKind(SyntaxKind8.Identifier))
-        continue;
-      if (knownModuleDefVars.has(obj.getText()))
+}
+var VALID_OPERATIONS = ["create", "read", "update", "list", "delete"];
+var VALID_PARTS = ["Body", "Response", "Query", "Params", "Headers"];
+function parseSchemaName(name) {
+  for (const op of VALID_OPERATIONS) {
+    if (!name.startsWith(op))
+      continue;
+    const rest = name.slice(op.length);
+    if (rest.length === 0)
+      continue;
+    for (const part of VALID_PARTS) {
+      if (!rest.endsWith(part))
         continue;
-      const varName = getVariableNameForCall(call);
-      if (!varName)
+      const entity = rest.slice(0, -part.length);
+      if (entity.length === 0)
         continue;
-      const hasHttpMethodCalls = Object.keys(HTTP_METHODS).some((method) => findMethodCallsOnVariable(file, varName, method).length > 0);
-      if (!hasHttpMethodCalls)
+      const firstChar = entity.at(0);
+      if (!firstChar || firstChar !== firstChar.toUpperCase())
         continue;
-      this.addDiagnostic(createDiagnosticFromLocation(getSourceLocation(call), {
-        severity: "error",
-        code: "VERTZ_RT_UNKNOWN_MODULE_DEF",
-        message: `'${obj.getText()}' is not a known moduleDef variable.`,
-        suggestion: "Ensure the variable is declared with vertz.moduleDef() and is included in the module context."
-      }));
+      return { operation: op, entity, part };
+    }
+  }
+  return {};
+}
+function isSchemaExpression(_file, expr) {
+  const root = findRootIdentifier(expr);
+  if (!root)
+    return false;
+  return isFromImport(root, "@vertz/schema");
+}
+function extractSchemaId(expr) {
+  let current = expr;
+  while (current.isKind(SyntaxKind5.CallExpression)) {
+    const access = current.getExpression();
+    if (access.isKind(SyntaxKind5.PropertyAccessExpression) && access.getName() === "id") {
+      const args = current.getArguments();
+      if (args.length === 1) {
+        const firstArg = args.at(0);
+        const value = firstArg ? getStringValue(firstArg) : null;
+        if (value !== null)
+          return value;
+      }
+    }
+    if (access.isKind(SyntaxKind5.PropertyAccessExpression)) {
+      current = access.getExpression();
+    } else {
+      break;
     }
   }
-  extractRoutes(file, routerVarName, prefix, moduleName) {
-    const routes = [];
-    const usedOperationIds = new Set;
-    for (const [methodName, httpMethod] of Object.entries(HTTP_METHODS)) {
-      const directCalls = findMethodCallsOnVariable(file, routerVarName, methodName);
-      const chainedCalls = this.findChainedHttpCalls(file, routerVarName, methodName);
-      const allCalls = [...directCalls, ...chainedCalls];
-      for (const call of allCalls) {
-        const route = this.extractRoute(call, httpMethod, prefix, moduleName, file, usedOperationIds);
-        if (route)
-          routes.push(route);
+  return null;
+}
+function isSchemaFile(file) {
+  return file.getImportDeclarations().some((decl) => decl.getModuleSpecifierValue() === "@vertz/schema");
+}
+function createNamedSchemaRef(schemaName, sourceFile) {
+  return { kind: "named", schemaName, sourceFile };
+}
+function createInlineSchemaRef(sourceFile) {
+  return { kind: "inline", sourceFile };
+}
+function findRootIdentifier(expr) {
+  if (expr.isKind(SyntaxKind5.CallExpression)) {
+    return findRootIdentifier(expr.getExpression());
+  }
+  if (expr.isKind(SyntaxKind5.PropertyAccessExpression)) {
+    return findRootIdentifier(expr.getExpression());
+  }
+  if (expr.isKind(SyntaxKind5.Identifier)) {
+    return expr;
+  }
+  return null;
+}
+
+// src/analyzers/env-analyzer.ts
+class EnvAnalyzer extends BaseAnalyzer {
+  async analyze() {
+    let env;
+    for (const file of this.project.getSourceFiles()) {
+      const calls = findCallExpressions(file, "vertz", "env");
+      for (const call of calls) {
+        const obj = extractObjectLiteral(call, 0);
+        if (!obj)
+          continue;
+        const loc = getSourceLocation(call);
+        if (env) {
+          this.addDiagnostic(createDiagnosticFromLocation(loc, {
+            severity: "error",
+            code: "VERTZ_ENV_DUPLICATE",
+            message: "Multiple vertz.env() calls found. Only one is allowed."
+          }));
+          continue;
+        }
+        const loadExpr = getPropertyValue(obj, "load");
+        const loadFiles = loadExpr ? getArrayElements(loadExpr).map((e) => getStringValue(e)).filter((v) => v !== null) : [];
+        const schemaExpr = getPropertyValue(obj, "schema");
+        let schema;
+        if (schemaExpr?.isKind(SyntaxKind6.Identifier)) {
+          schema = createNamedSchemaRef(schemaExpr.getText(), file.getFilePath());
+        }
+        env = {
+          ...loc,
+          loadFiles,
+          schema,
+          variables: []
+        };
       }
     }
-    return routes;
+    return { env };
   }
-  findChainedHttpCalls(file, routerVarName, methodName) {
-    return file.getDescendantsOfKind(SyntaxKind8.CallExpression).filter((call) => {
-      const expr = call.getExpression();
-      if (!expr.isKind(SyntaxKind8.PropertyAccessExpression))
-        return false;
-      if (expr.getName() !== methodName)
-        return false;
-      const obj = expr.getExpression();
-      if (!obj.isKind(SyntaxKind8.CallExpression))
-        return false;
-      return this.chainResolvesToVariable(obj, routerVarName);
-    });
+}
+// src/analyzers/middleware-analyzer.ts
+import { SyntaxKind as SyntaxKind8 } from "ts-morph";
+
+// src/analyzers/service-analyzer.ts
+import { SyntaxKind as SyntaxKind7 } from "ts-morph";
+class ServiceAnalyzer extends BaseAnalyzer {
+  async analyze() {
+    return { services: [] };
   }
-  chainResolvesToVariable(expr, varName) {
-    if (expr.isKind(SyntaxKind8.Identifier)) {
-      return expr.getText() === varName;
-    }
-    if (expr.isKind(SyntaxKind8.CallExpression)) {
-      const inner = expr.getExpression();
-      if (inner.isKind(SyntaxKind8.PropertyAccessExpression)) {
-        return this.chainResolvesToVariable(inner.getExpression(), varName);
+  async analyzeForModule(moduleDefVarName, moduleName) {
+    const services = [];
+    for (const file of this.project.getSourceFiles()) {
+      const calls = findMethodCallsOnVariable(file, moduleDefVarName, "service");
+      for (const call of calls) {
+        const name = getVariableNameForCall(call);
+        if (!name)
+          continue;
+        const obj = extractObjectLiteral(call, 0);
+        const inject = obj ? parseInjectFromObj(obj) : [];
+        const methods = obj ? parseMethodsFromObj(obj) : [];
+        const loc = getSourceLocation(call);
+        services.push({
+          name,
+          moduleName,
+          ...loc,
+          inject,
+          methods
+        });
       }
     }
-    return false;
+    return services;
   }
-  extractRoute(call, method, prefix, moduleName, file, usedOperationIds) {
-    const args = call.getArguments();
-    const pathArg = args[0];
-    if (!pathArg)
-      return null;
-    const path = getStringValue(pathArg);
-    if (path === null) {
-      this.addDiagnostic(createDiagnosticFromLocation(getSourceLocation(call), {
-        severity: "error",
-        code: "VERTZ_RT_DYNAMIC_PATH",
-        message: "Route paths must be string literals for static analysis.",
-        suggestion: "Use a string literal for the route path."
-      }));
-      return null;
-    }
-    const fullPath = joinPaths(prefix, path);
-    const loc = getSourceLocation(call);
-    const filePath = file.getFilePath();
-    const obj = extractObjectLiteral(call, 1);
-    if (!obj && args.length > 1) {
-      this.addDiagnostic(createDiagnosticFromLocation(loc, {
-        severity: "warning",
-        code: "VERTZ_RT_DYNAMIC_CONFIG",
-        message: "Route config must be an object literal for static analysis.",
-        suggestion: "Pass an inline object literal as the second argument."
-      }));
-    }
-    const params = obj ? this.resolveSchemaRef(obj, "params", filePath) : undefined;
-    const query = obj ? this.resolveSchemaRef(obj, "query", filePath) : undefined;
-    const body = obj ? this.resolveSchemaRef(obj, "body", filePath) : undefined;
-    const headers = obj ? this.resolveSchemaRef(obj, "headers", filePath) : undefined;
-    const response = obj ? this.resolveSchemaRef(obj, "response", filePath) : undefined;
-    const middleware = obj ? this.extractMiddlewareRefs(obj, filePath) : [];
-    const descriptionExpr = obj ? getPropertyValue(obj, "description") : null;
-    const description = descriptionExpr ? getStringValue(descriptionExpr) ?? undefined : undefined;
-    const tagsExpr = obj ? getPropertyValue(obj, "tags") : null;
-    const tags = tagsExpr ? getArrayElements(tagsExpr).map((e) => getStringValue(e)).filter((v) => v !== null) : [];
-    const handlerExpr = obj ? getPropertyValue(obj, "handler") : null;
-    const operationId = this.generateOperationId(moduleName, method, path, handlerExpr, usedOperationIds);
-    if (obj && !handlerExpr) {
-      this.addDiagnostic(createDiagnosticFromLocation(loc, {
-        severity: "error",
-        code: "VERTZ_RT_MISSING_HANDLER",
-        message: "Route must have a 'handler' property.",
-        suggestion: "Add a 'handler' property to the route config."
-      }));
-      return null;
-    }
-    return {
-      method,
-      path,
-      fullPath,
-      ...loc,
-      operationId,
-      params,
-      query,
-      body,
-      headers,
-      response,
-      middleware,
-      description,
-      tags
-    };
+}
+function parseInjectFromObj(obj) {
+  const injectExpr = getPropertyValue(obj, "inject");
+  if (!injectExpr?.isKind(SyntaxKind7.ObjectLiteralExpression))
+    return [];
+  return parseInjectRefs(injectExpr);
+}
+function parseMethodsFromObj(obj) {
+  const methodsExpr = getPropertyValue(obj, "methods");
+  if (!methodsExpr)
+    return [];
+  return extractMethodSignatures(methodsExpr);
+}
+function parseInjectRefs(obj) {
+  return getProperties(obj).map(({ name, value }) => {
+    const resolvedToken = value.isKind(SyntaxKind7.Identifier) ? value.getText() : name;
+    return { localName: name, resolvedToken };
+  });
+}
+function extractMethodSignatures(expr) {
+  if (!expr.isKind(SyntaxKind7.ArrowFunction) && !expr.isKind(SyntaxKind7.FunctionExpression)) {
+    return [];
   }
-  resolveSchemaRef(obj, prop, filePath) {
-    const expr = getPropertyValue(obj, prop);
-    if (!expr)
-      return;
-    if (expr.isKind(SyntaxKind8.Identifier)) {
-      const resolved = resolveIdentifier(expr, this.project);
-      const resolvedPath = resolved ? resolved.sourceFile.getFilePath() : filePath;
-      return createNamedSchemaRef(expr.getText(), resolvedPath);
+  const body = expr.getBody();
+  let returnObj = null;
+  if (body.isKind(SyntaxKind7.ObjectLiteralExpression)) {
+    returnObj = body;
+  } else if (body.isKind(SyntaxKind7.ParenthesizedExpression)) {
+    const inner = body.getExpression();
+    if (inner.isKind(SyntaxKind7.ObjectLiteralExpression)) {
+      returnObj = inner;
     }
-    if (isSchemaExpression(expr.getSourceFile(), expr)) {
-      return createInlineSchemaRef(filePath);
+  } else if (body.isKind(SyntaxKind7.Block)) {
+    const returnStmt = body.getStatements().find((s) => s.isKind(SyntaxKind7.ReturnStatement));
+    const retExpr = returnStmt?.asKind(SyntaxKind7.ReturnStatement)?.getExpression();
+    if (retExpr?.isKind(SyntaxKind7.ObjectLiteralExpression)) {
+      returnObj = retExpr;
     }
-    return;
   }
-  extractMiddlewareRefs(obj, filePath) {
-    const expr = getPropertyValue(obj, "middlewares");
-    if (!expr)
-      return [];
-    const elements = getArrayElements(expr);
-    return elements.filter((el) => el.isKind(SyntaxKind8.Identifier)).map((el) => {
-      const resolved = resolveIdentifier(el, this.project);
-      return {
-        name: el.getText(),
-        sourceFile: resolved ? resolved.sourceFile.getFilePath() : filePath
-      };
+  if (!returnObj)
+    return [];
+  const methods = [];
+  for (const prop of returnObj.getProperties()) {
+    if (!prop.isKind(SyntaxKind7.PropertyAssignment))
+      continue;
+    const methodName = prop.getName();
+    const init = prop.getInitializer();
+    if (!init)
+      continue;
+    const params = extractFunctionParams(init);
+    const returnType = inferReturnType(init);
+    methods.push({
+      name: methodName,
+      parameters: params,
+      returnType
     });
   }
-  generateOperationId(moduleName, method, path, handlerExpr, usedIds) {
-    let handlerName = null;
-    if (handlerExpr?.isKind(SyntaxKind8.Identifier)) {
-      handlerName = handlerExpr.getText();
-    } else if (handlerExpr?.isKind(SyntaxKind8.PropertyAccessExpression)) {
-      handlerName = handlerExpr.getName();
-    }
-    const id = handlerName ? `${moduleName}_${handlerName}` : `${moduleName}_${method.toLowerCase()}_${sanitizePath(path)}`;
-    if (!usedIds.has(id)) {
-      usedIds.add(id);
-      return id;
-    }
-    let counter = 2;
-    while (usedIds.has(`${id}_${counter}`))
-      counter++;
-    const uniqueId = `${id}_${counter}`;
-    usedIds.add(uniqueId);
-    return uniqueId;
-  }
+  return methods;
 }
-function joinPaths(prefix, path) {
-  const normalizedPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
-  if (path === "/")
-    return normalizedPrefix || "/";
-  return normalizedPrefix + path;
+function extractFunctionParams(expr) {
+  if (!expr.isKind(SyntaxKind7.ArrowFunction) && !expr.isKind(SyntaxKind7.FunctionExpression)) {
+    return [];
+  }
+  return expr.getParameters().map((p) => ({
+    name: p.getName(),
+    type: p.getType().getText(p)
+  }));
 }
-function sanitizePath(path) {
-  return path.replace(/^\//, "").replace(/[/:.]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "") || "root";
+function inferReturnType(expr) {
+  if (expr.isKind(SyntaxKind7.ArrowFunction) || expr.isKind(SyntaxKind7.FunctionExpression)) {
+    const retType = expr.getReturnType();
+    return retType.getText(expr);
+  }
+  return "unknown";
 }
-// src/analyzers/entity-analyzer.ts
-import { SyntaxKind as SyntaxKind9 } from "ts-morph";
-var ENTITY_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
-var CRUD_OPS = ["list", "get", "create", "update", "delete"];
 
-class EntityAnalyzer extends BaseAnalyzer {
-  debug(msg) {
-    if (process.env["VERTZ_DEBUG"]?.includes("entities")) {
-      console.log(`[entity-analyzer] ${msg}`);
-    }
-  }
+// src/analyzers/middleware-analyzer.ts
+class MiddlewareAnalyzer extends BaseAnalyzer {
   async analyze() {
-    const entities = [];
-    const seenNames = new Map;
-    const files = this.project.getSourceFiles();
-    this.debug(`Scanning ${files.length} source files...`);
-    for (const file of files) {
-      const calls = this.findEntityCalls(file);
+    const middleware = [];
+    for (const file of this.project.getSourceFiles()) {
+      const calls = findCallExpressions(file, "vertz", "middleware");
       for (const call of calls) {
-        const entity = this.extractEntity(file, call);
-        if (!entity)
-          continue;
-        const existing = seenNames.get(entity.name);
-        if (existing) {
-          this.addDiagnostic({
-            code: "ENTITY_DUPLICATE_NAME",
-            severity: "error",
-            message: `Entity "${entity.name}" is already defined at ${existing.sourceFile}:${existing.sourceLine}`,
-            ...getSourceLocation(call)
-          });
+        const obj = extractObjectLiteral(call, 0);
+        if (!obj) {
+          const callLoc = getSourceLocation(call);
+          this.addDiagnostic(createDiagnosticFromLocation(callLoc, {
+            severity: "warning",
+            code: "VERTZ_MW_NON_OBJECT_CONFIG",
+            message: "Middleware config must be an object literal for static analysis.",
+            suggestion: "Pass an inline object literal to vertz.middleware()."
+          }));
           continue;
         }
-        seenNames.set(entity.name, entity);
-        entities.push(entity);
-        this.debug(`Detected entity: "${entity.name}" at ${entity.sourceFile}:${entity.sourceLine}`);
-        this.debug(`  model: ${entity.modelRef.variableName} (resolved: ${entity.modelRef.schemaRefs.resolved ? "✅" : "❌"})`);
-        const accessStatus = CRUD_OPS.map((op) => {
-          const kind = entity.access[op];
-          return `${op} ${kind === "false" ? "✗" : "✓"}`;
-        }).join(", ");
-        this.debug(`  access: ${accessStatus}`);
-        if (entity.hooks.before.length > 0 || entity.hooks.after.length > 0) {
-          this.debug(`  hooks: before[${entity.hooks.before.join(",")}], after[${entity.hooks.after.join(",")}]`);
-        }
-        if (entity.actions.length > 0) {
-          this.debug(`  actions: ${entity.actions.map((a) => a.name).join(", ")}`);
-        }
-      }
-    }
-    return { entities };
-  }
-  findEntityCalls(file) {
-    const validCalls = [];
-    for (const call of file.getDescendantsOfKind(SyntaxKind9.CallExpression)) {
-      const expr = call.getExpression();
-      if (expr.isKind(SyntaxKind9.Identifier)) {
-        const isValid = isFromImport(expr, "@vertz/server");
-        if (!isValid && expr.getText() === "entity") {
-          this.addDiagnostic({
-            code: "ENTITY_UNRESOLVED_IMPORT",
+        const loc = getSourceLocation(call);
+        const nameExpr = getPropertyValue(obj, "name");
+        if (!nameExpr) {
+          this.addDiagnostic(createDiagnosticFromLocation(loc, {
             severity: "error",
-            message: "entity() call does not resolve to @vertz/server",
-            ...getSourceLocation(call)
-          });
+            code: "VERTZ_MW_MISSING_NAME",
+            message: "Middleware must have a 'name' property.",
+            suggestion: "Add a 'name' property to the middleware config."
+          }));
           continue;
         }
-        if (isValid) {
-          validCalls.push(call);
-        }
-        continue;
-      }
-      if (expr.isKind(SyntaxKind9.PropertyAccessExpression)) {
-        const propName = expr.getName();
-        if (propName !== "entity")
-          continue;
-        const obj = expr.getExpression();
-        if (!obj.isKind(SyntaxKind9.Identifier))
+        const name = getStringValue(nameExpr);
+        if (!name) {
+          this.addDiagnostic(createDiagnosticFromLocation(loc, {
+            severity: "warning",
+            code: "VERTZ_MW_DYNAMIC_NAME",
+            message: "Middleware name should be a string literal for static analysis.",
+            suggestion: "Use a string literal for the middleware name."
+          }));
           continue;
-        const sourceFile = obj.getSourceFile();
-        const importDecl = sourceFile.getImportDeclarations().find((d) => d.getModuleSpecifierValue() === "@vertz/server" && d.getNamespaceImport()?.getText() === obj.getText());
-        if (importDecl) {
-          validCalls.push(call);
         }
-      }
-    }
-    return validCalls;
-  }
-  extractEntity(_file, call) {
-    const args = call.getArguments();
-    const loc = getSourceLocation(call);
-    if (args.length < 2) {
-      this.addDiagnostic({
-        code: "ENTITY_MISSING_ARGS",
-        severity: "error",
-        message: "entity() requires two arguments: name and config",
-        ...loc
-      });
-      return null;
-    }
-    const name = getStringValue(args[0]);
-    if (name === null) {
-      this.addDiagnostic({
-        code: "ENTITY_NON_LITERAL_NAME",
-        severity: "error",
-        message: "entity() name must be a string literal",
-        ...loc
-      });
-      return null;
-    }
-    if (!ENTITY_NAME_PATTERN.test(name)) {
-      this.addDiagnostic({
-        code: "ENTITY_INVALID_NAME",
-        severity: "error",
-        message: `Entity name must match /^[a-z][a-z0-9-]*$/. Got: "${name}"`,
-        ...loc
-      });
-      return null;
-    }
-    const configObj = extractObjectLiteral(call, 1);
-    if (!configObj) {
-      this.addDiagnostic({
-        code: "ENTITY_CONFIG_NOT_OBJECT",
-        severity: "warning",
-        message: "entity() config must be an object literal for static analysis",
-        ...loc
-      });
-      return null;
-    }
-    const modelRef = this.extractModelRef(configObj, loc);
-    if (!modelRef)
-      return null;
-    const access = this.extractAccess(configObj);
-    const hooks = this.extractHooks(configObj);
-    const actions = this.extractActions(configObj);
-    const relations = this.extractRelations(configObj);
-    for (const action of actions) {
-      if (CRUD_OPS.includes(action.name)) {
-        this.addDiagnostic({
-          code: "ENTITY_ACTION_NAME_COLLISION",
-          severity: "error",
-          message: `Custom action "${action.name}" collides with built-in CRUD operation`,
-          ...action
-        });
-      }
-    }
-    for (const customOp of Object.keys(access.custom)) {
-      if (!actions.some((a) => a.name === customOp)) {
-        this.addDiagnostic({
-          code: "ENTITY_UNKNOWN_ACCESS_OP",
-          severity: "warning",
-          message: `Unknown access operation "${customOp}" — not a CRUD op or custom action`,
-          ...loc
-        });
-      }
-    }
-    return { name, modelRef, access, hooks, actions, relations, ...loc };
-  }
-  extractModelRef(configObj, loc) {
-    const modelExpr = getPropertyValue(configObj, "model");
-    if (!modelExpr) {
-      this.addDiagnostic({
-        code: "ENTITY_MISSING_MODEL",
-        severity: "error",
-        message: "entity() requires a model property",
-        ...loc
-      });
-      return null;
-    }
-    const variableName = modelExpr.isKind(SyntaxKind9.Identifier) ? modelExpr.getText() : modelExpr.getText();
-    let importSource;
-    if (modelExpr.isKind(SyntaxKind9.Identifier)) {
-      const importInfo = this.findImportForIdentifier(modelExpr);
-      if (importInfo) {
-        importSource = importInfo.importDecl.getModuleSpecifierValue();
-      }
-    }
-    const schemaRefs = this.resolveModelSchemas(modelExpr);
-    return { variableName, importSource, schemaRefs };
-  }
-  findImportForIdentifier(identifier) {
-    const sourceFile = identifier.getSourceFile();
-    const name = identifier.getText();
-    for (const importDecl of sourceFile.getImportDeclarations()) {
-      for (const specifier of importDecl.getNamedImports()) {
-        const localName = specifier.getAliasNode()?.getText() ?? specifier.getName();
-        if (localName === name) {
-          return { importDecl, originalName: specifier.getName() };
+        const handlerExpr = getPropertyValue(obj, "handler");
+        if (!handlerExpr) {
+          this.addDiagnostic(createDiagnosticFromLocation(loc, {
+            severity: "error",
+            code: "VERTZ_MW_MISSING_HANDLER",
+            message: "Middleware must have a 'handler' property.",
+            suggestion: "Add a 'handler' property to the middleware config."
+          }));
+          continue;
         }
-      }
-      const nsImport = importDecl.getNamespaceImport();
-      if (nsImport && nsImport.getText() === name) {
-        return { importDecl, originalName: "*" };
-      }
-    }
-    return null;
-  }
-  resolveModelSchemas(modelExpr) {
-    try {
-      const modelType = modelExpr.getType();
-      const schemasProp = modelType.getProperty("schemas");
-      if (!schemasProp)
-        return { resolved: false };
-      const schemasType = schemasProp.getTypeAtLocation(modelExpr);
-      const response = this.extractSchemaType(schemasType, "response", modelExpr);
-      const createInput = this.extractSchemaType(schemasType, "createInput", modelExpr);
-      const updateInput = this.extractSchemaType(schemasType, "updateInput", modelExpr);
-      return {
-        response,
-        createInput,
-        updateInput,
-        resolved: response !== undefined || createInput !== undefined || updateInput !== undefined
-      };
-    } catch {
-      return { resolved: false };
+        const injectExpr = getPropertyValue(obj, "inject");
+        const inject = injectExpr?.isKind(SyntaxKind8.ObjectLiteralExpression) ? parseInjectRefs(injectExpr) : [];
+        const filePath = file.getFilePath();
+        const headers = this.resolveSchemaRef(obj, "headers", filePath);
+        const params = this.resolveSchemaRef(obj, "params", filePath);
+        const query = this.resolveSchemaRef(obj, "query", filePath);
+        const body = this.resolveSchemaRef(obj, "body", filePath);
+        const requires = this.resolveSchemaRef(obj, "requires", filePath);
+        const provides = this.resolveSchemaRef(obj, "provides", filePath);
+        middleware.push({
+          name,
+          ...loc,
+          inject,
+          headers,
+          params,
+          query,
+          body,
+          requires,
+          provides
+        });
+      }
     }
+    return { middleware };
   }
-  extractSchemaType(parentType, propertyName, location) {
-    const prop = parentType.getProperty(propertyName);
-    if (!prop)
+  resolveSchemaRef(obj, prop, filePath) {
+    const expr = getPropertyValue(obj, prop);
+    if (!expr)
       return;
-    const propType = prop.getTypeAtLocation(location);
-    const resolvedFields = this.resolveFieldsFromSchemaType(propType, location);
-    const jsonSchema = this.buildJsonSchema(resolvedFields);
-    return {
-      kind: "inline",
-      sourceFile: location.getSourceFile().getFilePath(),
-      jsonSchema,
-      resolvedFields
-    };
-  }
-  buildJsonSchema(resolvedFields) {
-    if (!resolvedFields || resolvedFields.length === 0) {
-      return {};
+    if (expr.isKind(SyntaxKind8.Identifier)) {
+      const resolved = resolveIdentifier(expr, this.project);
+      const resolvedPath = resolved ? resolved.sourceFile.getFilePath() : filePath;
+      return createNamedSchemaRef(expr.getText(), resolvedPath);
     }
-    const properties = {};
-    const required = [];
-    for (const field of resolvedFields) {
-      const fieldSchema = this.tsTypeToJsonSchema(field.tsType);
-      properties[field.name] = fieldSchema;
-      if (!field.optional) {
-        required.push(field.name);
-      }
+    if (isSchemaExpression(expr.getSourceFile(), expr)) {
+      return createInlineSchemaRef(filePath);
     }
-    return {
-      type: "object",
-      properties,
-      ...required.length > 0 ? { required } : {}
-    };
+    return;
   }
-  tsTypeToJsonSchema(tsType) {
-    switch (tsType) {
-      case "string":
-        return { type: "string" };
-      case "number":
-        return { type: "number" };
-      case "boolean":
-        return { type: "boolean" };
-      case "date":
-        return { type: "string", format: "date-time" };
-      case "unknown":
-      default:
-        return {};
+}
+// src/analyzers/module-analyzer.ts
+import { SyntaxKind as SyntaxKind9 } from "ts-morph";
+class ModuleAnalyzer extends BaseAnalyzer {
+  async analyze() {
+    const modules = [];
+    const defVarToIndex = new Map;
+    for (const file of this.project.getSourceFiles()) {
+      const defCalls = findCallExpressions(file, "vertz", "moduleDef");
+      for (const call of defCalls) {
+        const obj = extractObjectLiteral(call, 0);
+        if (!obj)
+          continue;
+        const nameExpr = getPropertyValue(obj, "name");
+        const name = nameExpr ? getStringValue(nameExpr) : null;
+        if (!name) {
+          this.addDiagnostic(createDiagnosticFromLocation(getSourceLocation(call), {
+            severity: "error",
+            code: "VERTZ_MODULE_DYNAMIC_NAME",
+            message: "vertz.moduleDef() requires a static string `name` property."
+          }));
+          continue;
+        }
+        const varName = getVariableNameForCall(call);
+        const importsExpr = getPropertyValue(obj, "imports");
+        const imports = importsExpr?.isKind(SyntaxKind9.ObjectLiteralExpression) ? parseImports(importsExpr) : [];
+        const optionsExpr = getPropertyValue(obj, "options");
+        let options;
+        if (optionsExpr?.isKind(SyntaxKind9.Identifier)) {
+          options = createNamedSchemaRef(optionsExpr.getText(), file.getFilePath());
+        }
+        const loc = getSourceLocation(call);
+        const idx = modules.length;
+        modules.push({
+          name,
+          ...loc,
+          imports,
+          options,
+          services: [],
+          routers: [],
+          exports: []
+        });
+        if (varName) {
+          defVarToIndex.set(varName, idx);
+        }
+      }
     }
-  }
-  resolveFieldsFromSchemaType(schemaType, location) {
-    try {
-      const parseProp = schemaType.getProperty("parse");
-      if (!parseProp)
-        return;
-      const parseType = parseProp.getTypeAtLocation(location);
-      const callSignatures = parseType.getCallSignatures();
-      if (callSignatures.length === 0)
-        return;
-      const returnType = callSignatures[0]?.getReturnType();
-      if (!returnType)
-        return;
-      const dataType = this.unwrapResultType(returnType, location);
-      if (!dataType)
-        return;
-      const properties = dataType.getProperties();
-      if (properties.length === 0)
-        return;
-      const fields = [];
-      for (const fieldProp of properties) {
-        const name = fieldProp.getName();
-        const fieldType = fieldProp.getTypeAtLocation(location);
-        const optional = fieldProp.isOptional();
-        const tsType = this.mapTsType(fieldType);
-        fields.push({ name, tsType, optional });
+    for (const file of this.project.getSourceFiles()) {
+      const moduleCalls = findCallExpressions(file, "vertz", "module");
+      for (const call of moduleCalls) {
+        const args = call.getArguments();
+        if (args.length < 2)
+          continue;
+        const defArg = args.at(0);
+        if (!defArg?.isKind(SyntaxKind9.Identifier))
+          continue;
+        const defVarName = defArg.getText();
+        const idx = defVarToIndex.get(defVarName);
+        if (idx === undefined)
+          continue;
+        const mod = modules.at(idx);
+        if (!mod)
+          continue;
+        const assemblyObj = extractObjectLiteral(call, 1);
+        if (!assemblyObj)
+          continue;
+        const exportsExpr = getPropertyValue(assemblyObj, "exports");
+        if (exportsExpr) {
+          mod.exports = extractIdentifierNames(exportsExpr);
+        }
       }
-      return fields;
-    } catch {
-      return;
     }
+    return { modules };
   }
-  unwrapResultType(type, location) {
-    if (type.isUnion()) {
-      for (const member of type.getUnionTypes()) {
-        const dataProp2 = member.getProperty("data");
-        if (dataProp2) {
-          return dataProp2.getTypeAtLocation(location);
+}
+function parseImports(obj) {
+  return getProperties(obj).map(({ name }) => ({
+    localName: name,
+    isEnvImport: false
+  }));
+}
+function extractIdentifierNames(expr) {
+  if (!expr.isKind(SyntaxKind9.ArrayLiteralExpression))
+    return [];
+  return expr.getElements().filter((e) => e.isKind(SyntaxKind9.Identifier)).map((e) => e.getText());
+}
+// src/analyzers/route-analyzer.ts
+import { SyntaxKind as SyntaxKind10 } from "ts-morph";
+var HTTP_METHODS = {
+  get: "GET",
+  post: "POST",
+  put: "PUT",
+  patch: "PATCH",
+  delete: "DELETE",
+  head: "HEAD"
+};
+
+class RouteAnalyzer extends BaseAnalyzer {
+  async analyze() {
+    return { routers: [] };
+  }
+  async analyzeForModules(context) {
+    const routers = [];
+    const knownModuleDefVars = new Set(context.moduleDefVariables.keys());
+    for (const file of this.project.getSourceFiles()) {
+      for (const [moduleDefVar, moduleName] of context.moduleDefVariables) {
+        const routerCalls = findMethodCallsOnVariable(file, moduleDefVar, "router");
+        for (const call of routerCalls) {
+          const varName = getVariableNameForCall(call);
+          if (!varName)
+            continue;
+          const obj = extractObjectLiteral(call, 0);
+          const prefixExpr = obj ? getPropertyValue(obj, "prefix") : null;
+          const prefix = prefixExpr ? getStringValue(prefixExpr) ?? "/" : "/";
+          if (!prefixExpr) {
+            this.addDiagnostic(createDiagnosticFromLocation(getSourceLocation(call), {
+              severity: "warning",
+              code: "VERTZ_RT_MISSING_PREFIX",
+              message: "Router should have a 'prefix' property.",
+              suggestion: "Add a 'prefix' property to the router config."
+            }));
+          }
+          const loc = getSourceLocation(call);
+          const injectExpr = obj ? getPropertyValue(obj, "inject") : null;
+          const inject = injectExpr?.isKind(SyntaxKind10.ObjectLiteralExpression) ? parseInjectRefs(injectExpr) : [];
+          const routes = this.extractRoutes(file, varName, prefix, moduleName);
+          routers.push({
+            name: varName,
+            moduleName,
+            ...loc,
+            prefix,
+            inject,
+            routes
+          });
         }
       }
-      return;
+      this.detectUnknownRouterCalls(file, knownModuleDefVars);
     }
-    const dataProp = type.getProperty("data");
-    if (dataProp) {
-      return dataProp.getTypeAtLocation(location);
+    return { routers };
+  }
+  detectUnknownRouterCalls(file, knownModuleDefVars) {
+    const allCalls = file.getDescendantsOfKind(SyntaxKind10.CallExpression);
+    for (const call of allCalls) {
+      const expr = call.getExpression();
+      if (!expr.isKind(SyntaxKind10.PropertyAccessExpression))
+        continue;
+      if (expr.getName() !== "router")
+        continue;
+      const obj = expr.getExpression();
+      if (!obj.isKind(SyntaxKind10.Identifier))
+        continue;
+      if (knownModuleDefVars.has(obj.getText()))
+        continue;
+      const varName = getVariableNameForCall(call);
+      if (!varName)
+        continue;
+      const hasHttpMethodCalls = Object.keys(HTTP_METHODS).some((method) => findMethodCallsOnVariable(file, varName, method).length > 0);
+      if (!hasHttpMethodCalls)
+        continue;
+      this.addDiagnostic(createDiagnosticFromLocation(getSourceLocation(call), {
+        severity: "error",
+        code: "VERTZ_RT_UNKNOWN_MODULE_DEF",
+        message: `'${obj.getText()}' is not a known moduleDef variable.`,
+        suggestion: "Ensure the variable is declared with vertz.moduleDef() and is included in the module context."
+      }));
     }
-    return type;
   }
-  mapTsType(type) {
-    const typeText = type.getText();
-    if (type.isUnion()) {
-      const nonUndefined = type.getUnionTypes().filter((t) => !t.isUndefined());
-      if (nonUndefined.length === 1 && nonUndefined[0]) {
-        return this.mapTsType(nonUndefined[0]);
+  extractRoutes(file, routerVarName, prefix, moduleName) {
+    const routes = [];
+    const usedOperationIds = new Set;
+    for (const [methodName, httpMethod] of Object.entries(HTTP_METHODS)) {
+      const directCalls = findMethodCallsOnVariable(file, routerVarName, methodName);
+      const chainedCalls = this.findChainedHttpCalls(file, routerVarName, methodName);
+      const allCalls = [...directCalls, ...chainedCalls];
+      for (const call of allCalls) {
+        const route = this.extractRoute(call, httpMethod, prefix, moduleName, file, usedOperationIds);
+        if (route)
+          routes.push(route);
       }
     }
-    if (type.isString() || type.isStringLiteral())
-      return "string";
-    if (type.isNumber() || type.isNumberLiteral())
-      return "number";
-    if (type.isBoolean() || type.isBooleanLiteral())
-      return "boolean";
-    if (typeText === "Date")
-      return "date";
-    return "unknown";
+    return routes;
   }
-  extractAccess(configObj) {
-    const defaults = {
-      list: "none",
-      get: "none",
-      create: "none",
-      update: "none",
-      delete: "none",
-      custom: {}
-    };
-    const accessExpr = getPropertyValue(configObj, "access");
-    if (!accessExpr || !accessExpr.isKind(SyntaxKind9.ObjectLiteralExpression))
-      return defaults;
-    const result = { ...defaults };
-    const knownOps = new Set([...CRUD_OPS]);
-    for (const { name, value } of getProperties(accessExpr)) {
-      const kind = this.classifyAccessRule(value);
-      if (knownOps.has(name)) {
-        result[name] = kind;
-      } else {
-        result.custom[name] = kind;
+  findChainedHttpCalls(file, routerVarName, methodName) {
+    return file.getDescendantsOfKind(SyntaxKind10.CallExpression).filter((call) => {
+      const expr = call.getExpression();
+      if (!expr.isKind(SyntaxKind10.PropertyAccessExpression))
+        return false;
+      if (expr.getName() !== methodName)
+        return false;
+      const obj = expr.getExpression();
+      if (!obj.isKind(SyntaxKind10.CallExpression))
+        return false;
+      return this.chainResolvesToVariable(obj, routerVarName);
+    });
+  }
+  chainResolvesToVariable(expr, varName) {
+    if (expr.isKind(SyntaxKind10.Identifier)) {
+      return expr.getText() === varName;
+    }
+    if (expr.isKind(SyntaxKind10.CallExpression)) {
+      const inner = expr.getExpression();
+      if (inner.isKind(SyntaxKind10.PropertyAccessExpression)) {
+        return this.chainResolvesToVariable(inner.getExpression(), varName);
       }
     }
-    return result;
+    return false;
   }
-  classifyAccessRule(expr) {
-    const boolVal = getBooleanValue(expr);
-    if (boolVal === false)
-      return "false";
-    if (boolVal === true)
-      return "none";
-    return "function";
+  extractRoute(call, method, prefix, moduleName, file, usedOperationIds) {
+    const args = call.getArguments();
+    const pathArg = args[0];
+    if (!pathArg)
+      return null;
+    const path = getStringValue(pathArg);
+    if (path === null) {
+      this.addDiagnostic(createDiagnosticFromLocation(getSourceLocation(call), {
+        severity: "error",
+        code: "VERTZ_RT_DYNAMIC_PATH",
+        message: "Route paths must be string literals for static analysis.",
+        suggestion: "Use a string literal for the route path."
+      }));
+      return null;
+    }
+    const fullPath = joinPaths(prefix, path);
+    const loc = getSourceLocation(call);
+    const filePath = file.getFilePath();
+    const obj = extractObjectLiteral(call, 1);
+    if (!obj && args.length > 1) {
+      this.addDiagnostic(createDiagnosticFromLocation(loc, {
+        severity: "warning",
+        code: "VERTZ_RT_DYNAMIC_CONFIG",
+        message: "Route config must be an object literal for static analysis.",
+        suggestion: "Pass an inline object literal as the second argument."
+      }));
+    }
+    const params = obj ? this.resolveSchemaRef(obj, "params", filePath) : undefined;
+    const query = obj ? this.resolveSchemaRef(obj, "query", filePath) : undefined;
+    const body = obj ? this.resolveSchemaRef(obj, "body", filePath) : undefined;
+    const headers = obj ? this.resolveSchemaRef(obj, "headers", filePath) : undefined;
+    const response = obj ? this.resolveSchemaRef(obj, "response", filePath) : undefined;
+    const middleware = obj ? this.extractMiddlewareRefs(obj, filePath) : [];
+    const descriptionExpr = obj ? getPropertyValue(obj, "description") : null;
+    const description = descriptionExpr ? getStringValue(descriptionExpr) ?? undefined : undefined;
+    const tagsExpr = obj ? getPropertyValue(obj, "tags") : null;
+    const tags = tagsExpr ? getArrayElements(tagsExpr).map((e) => getStringValue(e)).filter((v) => v !== null) : [];
+    const handlerExpr = obj ? getPropertyValue(obj, "handler") : null;
+    const operationId = this.generateOperationId(moduleName, method, path, handlerExpr, usedOperationIds);
+    if (obj && !handlerExpr) {
+      this.addDiagnostic(createDiagnosticFromLocation(loc, {
+        severity: "error",
+        code: "VERTZ_RT_MISSING_HANDLER",
+        message: "Route must have a 'handler' property.",
+        suggestion: "Add a 'handler' property to the route config."
+      }));
+      return null;
+    }
+    return {
+      method,
+      path,
+      fullPath,
+      ...loc,
+      operationId,
+      params,
+      query,
+      body,
+      headers,
+      response,
+      middleware,
+      description,
+      tags
+    };
   }
-  extractHooks(configObj) {
-    const hooks = { before: [], after: [] };
-    const beforeExpr = getPropertyValue(configObj, "before");
-    if (beforeExpr?.isKind(SyntaxKind9.ObjectLiteralExpression)) {
-      for (const { name } of getProperties(beforeExpr)) {
-        if (name === "create" || name === "update")
-          hooks.before.push(name);
-      }
+  resolveSchemaRef(obj, prop, filePath) {
+    const expr = getPropertyValue(obj, prop);
+    if (!expr)
+      return;
+    if (expr.isKind(SyntaxKind10.Identifier)) {
+      const resolved = resolveIdentifier(expr, this.project);
+      const resolvedPath = resolved ? resolved.sourceFile.getFilePath() : filePath;
+      return createNamedSchemaRef(expr.getText(), resolvedPath);
     }
-    const afterExpr = getPropertyValue(configObj, "after");
-    if (afterExpr?.isKind(SyntaxKind9.ObjectLiteralExpression)) {
-      for (const { name } of getProperties(afterExpr)) {
-        if (name === "create" || name === "update" || name === "delete")
-          hooks.after.push(name);
-      }
+    if (isSchemaExpression(expr.getSourceFile(), expr)) {
+      return createInlineSchemaRef(filePath);
     }
-    return hooks;
+    return;
   }
-  extractActions(configObj) {
-    const actionsExpr = getPropertyValue(configObj, "actions");
-    if (!actionsExpr?.isKind(SyntaxKind9.ObjectLiteralExpression))
+  extractMiddlewareRefs(obj, filePath) {
+    const expr = getPropertyValue(obj, "middlewares");
+    if (!expr)
       return [];
-    return getProperties(actionsExpr).map(({ name, value }) => {
-      const actionObj = value.isKind(SyntaxKind9.ObjectLiteralExpression) ? value : null;
-      const loc = getSourceLocation(value);
-      const bodyExpr = actionObj ? getPropertyValue(actionObj, "body") : null;
-      const responseExpr = actionObj ? getPropertyValue(actionObj, "response") : null;
-      if (!bodyExpr && !responseExpr) {
-        this.addDiagnostic({
-          code: "ENTITY_ACTION_MISSING_SCHEMA",
-          severity: "warning",
-          message: `Custom action "${name}" is missing body and response schema`,
-          ...loc
-        });
-      }
-      const body = bodyExpr ? this.resolveSchemaFromExpression(bodyExpr, loc) : undefined;
-      const response = responseExpr ? this.resolveSchemaFromExpression(responseExpr, loc) : undefined;
-      const methodExpr = actionObj ? getPropertyValue(actionObj, "method") : null;
-      let method = "POST";
-      if (methodExpr) {
-        const methodStr = getStringValue(methodExpr);
-        const validMethods = [
-          "GET",
-          "POST",
-          "PUT",
-          "DELETE",
-          "PATCH",
-          "HEAD",
-          "OPTIONS"
-        ];
-        if (methodStr && validMethods.includes(methodStr)) {
-          method = methodStr;
-        } else {
-          this.addDiagnostic({
-            code: "ENTITY_ACTION_INVALID_METHOD",
-            severity: "error",
-            message: `Custom action "${name}" has invalid method "${methodStr ?? "(non-string)"}" — must be one of GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS`,
-            ...loc
-          });
-        }
-      }
-      const pathExpr = actionObj ? getPropertyValue(actionObj, "path") : null;
-      const path = pathExpr ? getStringValue(pathExpr) ?? undefined : undefined;
-      const queryExpr = actionObj ? getPropertyValue(actionObj, "query") : null;
-      const queryRef = queryExpr ? this.resolveSchemaFromExpression(queryExpr, loc) : undefined;
-      const paramsExpr = actionObj ? getPropertyValue(actionObj, "params") : null;
-      const paramsRef = paramsExpr ? this.resolveSchemaFromExpression(paramsExpr, loc) : undefined;
-      const headersExpr = actionObj ? getPropertyValue(actionObj, "headers") : null;
-      const headersRef = headersExpr ? this.resolveSchemaFromExpression(headersExpr, loc) : undefined;
+    const elements = getArrayElements(expr);
+    return elements.filter((el) => el.isKind(SyntaxKind10.Identifier)).map((el) => {
+      const resolved = resolveIdentifier(el, this.project);
       return {
-        name,
-        method,
-        path,
-        params: paramsRef,
-        query: queryRef,
-        headers: headersRef,
-        body,
-        response,
-        ...loc
+        name: el.getText(),
+        sourceFile: resolved ? resolved.sourceFile.getFilePath() : filePath
       };
     });
   }
-  resolveSchemaFromExpression(expr, loc) {
-    if (expr.isKind(SyntaxKind9.Identifier)) {
-      const varName = expr.getText();
-      return { kind: "named", schemaName: varName, sourceFile: loc.sourceFile };
+  generateOperationId(moduleName, method, path, handlerExpr, usedIds) {
+    let handlerName = null;
+    if (handlerExpr?.isKind(SyntaxKind10.Identifier)) {
+      handlerName = handlerExpr.getText();
+    } else if (handlerExpr?.isKind(SyntaxKind10.PropertyAccessExpression)) {
+      handlerName = handlerExpr.getName();
     }
-    try {
-      const typeText = expr.getType().getText();
-      return { kind: "inline", sourceFile: loc.sourceFile, jsonSchema: { __typeText: typeText } };
-    } catch {
-      return { kind: "inline", sourceFile: loc.sourceFile };
+    const id = handlerName ? `${moduleName}_${handlerName}` : `${moduleName}_${method.toLowerCase()}_${sanitizePath(path)}`;
+    if (!usedIds.has(id)) {
+      usedIds.add(id);
+      return id;
     }
+    let counter = 2;
+    while (usedIds.has(`${id}_${counter}`))
+      counter++;
+    const uniqueId = `${id}_${counter}`;
+    usedIds.add(uniqueId);
+    return uniqueId;
   }
-  extractRelations(configObj) {
-    const relExpr = getPropertyValue(configObj, "relations");
-    if (!relExpr?.isKind(SyntaxKind9.ObjectLiteralExpression))
-      return [];
-    return getProperties(relExpr).filter(({ value }) => {
-      const boolVal = getBooleanValue(value);
-      return boolVal !== false;
-    }).map(({ name, value }) => {
-      const boolVal = getBooleanValue(value);
-      if (boolVal === true)
-        return { name, selection: "all" };
-      if (value.isKind(SyntaxKind9.ObjectLiteralExpression)) {
-        const fields = getProperties(value).map((p) => p.name);
-        return { name, selection: fields };
-      }
-      return { name, selection: "all" };
-    });
-  }
+}
+function joinPaths(prefix, path) {
+  const normalizedPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+  if (path === "/")
+    return normalizedPrefix || "/";
+  return normalizedPrefix + path;
+}
+function sanitizePath(path) {
+  return path.replace(/^\//, "").replace(/[/:.]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "") || "root";
 }
 // src/compiler.ts
 import { mkdir } from "node:fs/promises";
@@ -2340,6 +2528,7 @@ function createEmptyAppIR() {
     middleware: [],
     schemas: [],
     entities: [],
+    databases: [],
     dependencyGraph: createEmptyDependencyGraph(),
     diagnostics: []
   };
@@ -2553,6 +2742,7 @@ class CompletenessValidator {
     this.checkPathParamMatch(ir, diagnostics);
     this.checkModuleOptions(ir, diagnostics);
     this.checkRoutePathFormat(ir, diagnostics);
+    this.checkEntityModelRegistration(ir, diagnostics);
     return diagnostics;
   }
   checkResponseSchemas(ir, diagnostics) {
@@ -2760,6 +2950,27 @@ class CompletenessValidator {
       }
     }
   }
+  checkEntityModelRegistration(ir, diagnostics) {
+    if (ir.databases.length === 0)
+      return;
+    const allModelKeys = new Set;
+    for (const db of ir.databases) {
+      for (const key of db.modelKeys) {
+        allModelKeys.add(key);
+      }
+    }
+    for (const entity of ir.entities) {
+      if (!allModelKeys.has(entity.name)) {
+        const registeredList = ir.databases.flatMap((db) => db.modelKeys.map((key) => `"${key}" (${db.sourceFile}:${db.sourceLine})`)).join(", ");
+        diagnostics.push(createDiagnosticFromLocation(entity, {
+          severity: "error",
+          code: "ENTITY_MODEL_NOT_REGISTERED",
+          message: `Entity "${entity.name}" is not registered in any createDb() call. ` + `Add "${entity.name}: ${entity.modelRef.variableName}" to the models object in createDb().`,
+          suggestion: registeredList ? `Registered models: ${registeredList}` : "No models registered in any createDb() call."
+        }));
+      }
+    }
+  }
   checkCtxKeyCollisions(ir, diagnostics) {
     const keyProviders = new Map;
     for (const mw of ir.middleware) {
@@ -3058,6 +3269,7 @@ class Compiler {
     const middlewareResult = await analyzers.middleware.analyze();
     const appResult = await analyzers.app.analyze();
     const entityResult = await analyzers.entity.analyze();
+    const databaseResult = await analyzers.database.analyze();
     const depGraphResult = await analyzers.dependencyGraph.analyze();
     ir.env = envResult.env;
     ir.schemas = schemaResult.schemas;
@@ -3065,8 +3277,9 @@ class Compiler {
     ir.middleware = middlewareResult.middleware;
     ir.app = appResult.app;
     ir.entities = entityResult.entities;
+    ir.databases = databaseResult.databases;
     ir.dependencyGraph = depGraphResult.graph;
-    ir.diagnostics.push(...analyzers.env.getDiagnostics(), ...analyzers.schema.getDiagnostics(), ...analyzers.middleware.getDiagnostics(), ...analyzers.module.getDiagnostics(), ...analyzers.app.getDiagnostics(), ...analyzers.entity.getDiagnostics(), ...analyzers.dependencyGraph.getDiagnostics());
+    ir.diagnostics.push(...analyzers.env.getDiagnostics(), ...analyzers.schema.getDiagnostics(), ...analyzers.middleware.getDiagnostics(), ...analyzers.module.getDiagnostics(), ...analyzers.app.getDiagnostics(), ...analyzers.entity.getDiagnostics(), ...analyzers.database.getDiagnostics(), ...analyzers.dependencyGraph.getDiagnostics());
     injectEntityRoutes(ir);
     const collisionDiags = detectRouteCollisions(ir);
     ir.diagnostics.push(...collisionDiags);
@@ -3110,6 +3323,7 @@ function createCompiler(config) {
       module: new ModuleAnalyzer(project, resolved),
       app: new AppAnalyzer(project, resolved),
       entity: new EntityAnalyzer(project, resolved),
+      database: new DatabaseAnalyzer(project, resolved),
       dependencyGraph: new DependencyGraphAnalyzer(project, resolved)
     },
     validators: [
@@ -3473,6 +3687,7 @@ export {
   EnvAnalyzer,
   EntityAnalyzer,
   DependencyGraphAnalyzer,
+  DatabaseAnalyzer,
   CompletenessValidator,
   Compiler,
   BootGenerator,