@vertz/compiler 0.2.0 → 0.2.3

package/dist/index.js

@@ -1272,7 +1272,483 @@ function joinPaths(prefix, path) {
 function sanitizePath(path) {
   return path.replace(/^\//, "").replace(/[/:.]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "") || "root";
 }
+// 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}`);
+    }
+  }
+  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);
+      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)
+          });
+          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",
+            severity: "error",
+            message: "entity() call does not resolve to @vertz/server",
+            ...getSourceLocation(call)
+          });
+          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))
+          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 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 };
+    }
+  }
+  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);
+        }
+      }
+      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(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;
+      }
+    }
+    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(SyntaxKind9.ObjectLiteralExpression)) {
+      for (const { name } of getProperties(beforeExpr)) {
+        if (name === "create" || name === "update")
+          hooks.before.push(name);
+      }
+    }
+    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);
+      }
+    }
+    return hooks;
+  }
+  extractActions(configObj) {
+    const actionsExpr = getPropertyValue(configObj, "actions");
+    if (!actionsExpr?.isKind(SyntaxKind9.ObjectLiteralExpression))
+      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;
+      return {
+        name,
+        method,
+        path,
+        params: paramsRef,
+        query: queryRef,
+        headers: headersRef,
+        body,
+        response,
+        ...loc
+      };
+    });
+  }
+  resolveSchemaFromExpression(expr, loc) {
+    if (expr.isKind(SyntaxKind9.Identifier)) {
+      const varName = expr.getText();
+      return { kind: "named", schemaName: varName, sourceFile: loc.sourceFile };
+    }
+    try {
+      const typeText = expr.getType().getText();
+      return { kind: "inline", sourceFile: loc.sourceFile, jsonSchema: { __typeText: typeText } };
+    } catch {
+      return { kind: "inline", sourceFile: loc.sourceFile };
+    }
+  }
+  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" };
+    });
+  }
+}
 // src/compiler.ts
+import { mkdir } from "node:fs/promises";
+import { resolve } from "node:path";
 import { Project } from "ts-morph";
 
 // src/config.ts
@@ -1863,6 +2339,7 @@ function createEmptyAppIR() {
     modules: [],
     middleware: [],
     schemas: [],
+    entities: [],
     dependencyGraph: createEmptyDependencyGraph(),
     diagnostics: []
   };
@@ -1894,6 +2371,162 @@ function addDiagnosticsToIR(ir, diagnostics) {
   };
 }
 
+// src/ir/entity-route-injector.ts
+var SYNTHETIC_MODULE = "__entities";
+function toPascalCase(s) {
+  return s.split("-").map((w) => w[0]?.toUpperCase() + w.slice(1)).join("");
+}
+function injectEntityRoutes(ir) {
+  if (!ir.entities.length)
+    return;
+  const routes = [];
+  for (const entity of ir.entities) {
+    routes.push(...generateCrudRoutes(entity));
+    routes.push(...generateActionRoutes(entity));
+  }
+  if (!routes.length)
+    return;
+  const router = {
+    name: `${SYNTHETIC_MODULE}_router`,
+    moduleName: SYNTHETIC_MODULE,
+    prefix: "",
+    inject: [],
+    routes,
+    sourceFile: "",
+    sourceLine: 0,
+    sourceColumn: 0
+  };
+  const module = {
+    name: SYNTHETIC_MODULE,
+    imports: [],
+    services: [],
+    routers: [router],
+    exports: [],
+    sourceFile: "",
+    sourceLine: 0,
+    sourceColumn: 0
+  };
+  ir.modules.push(module);
+}
+function generateCrudRoutes(entity) {
+  const entityPascal = toPascalCase(entity.name);
+  const basePath = `/${entity.name}`;
+  const routes = [];
+  const ops = [
+    { op: "list", method: "GET", path: basePath, idParam: false },
+    { op: "get", method: "GET", path: `${basePath}/:id`, idParam: true },
+    { op: "create", method: "POST", path: basePath, idParam: false },
+    { op: "update", method: "PATCH", path: `${basePath}/:id`, idParam: true },
+    { op: "delete", method: "DELETE", path: `${basePath}/:id`, idParam: true }
+  ];
+  for (const { op, method, path } of ops) {
+    const accessKind = entity.access[op];
+    if (accessKind === "false")
+      continue;
+    const route = {
+      method,
+      path,
+      fullPath: path,
+      operationId: `${op}${entityPascal}`,
+      middleware: [],
+      tags: [entity.name],
+      description: `${op} ${entity.name}`,
+      ...entity
+    };
+    if (entity.modelRef.schemaRefs.resolved) {
+      if (op === "create") {
+        route.body = entity.modelRef.schemaRefs.createInput;
+        route.response = entity.modelRef.schemaRefs.response;
+      } else if (op === "update") {
+        route.body = entity.modelRef.schemaRefs.updateInput;
+        route.response = entity.modelRef.schemaRefs.response;
+      } else if (op === "list") {
+        route.response = wrapInPaginatedEnvelope(entity.modelRef.schemaRefs.response);
+      } else {
+        route.response = entity.modelRef.schemaRefs.response;
+      }
+    }
+    routes.push(route);
+  }
+  return routes;
+}
+function wrapInPaginatedEnvelope(itemSchema) {
+  if (!itemSchema)
+    return;
+  const itemJsonSchema = itemSchema.kind === "named" ? { $ref: `#/components/schemas/${itemSchema.schemaName}` } : itemSchema.jsonSchema ?? {};
+  return {
+    kind: "inline",
+    sourceFile: itemSchema.sourceFile,
+    jsonSchema: {
+      type: "object",
+      properties: {
+        items: { type: "array", items: itemJsonSchema },
+        total: { type: "number" },
+        limit: { type: "number" },
+        nextCursor: { type: ["string", "null"] },
+        hasNextPage: { type: "boolean" }
+      },
+      required: ["items", "total", "limit", "nextCursor", "hasNextPage"]
+    }
+  };
+}
+function generateActionRoutes(entity) {
+  const entityPascal = toPascalCase(entity.name);
+  return entity.actions.filter((action) => entity.access.custom[action.name] !== "false").map((action) => {
+    const method = action.method;
+    const path = action.path ? `/${entity.name}/${action.path}` : `/${entity.name}/:id/${action.name}`;
+    const fullPath = path;
+    return {
+      method,
+      path,
+      fullPath,
+      operationId: `${action.name}${entityPascal}`,
+      params: action.params,
+      query: action.query,
+      headers: action.headers,
+      body: action.body,
+      response: action.response,
+      middleware: [],
+      tags: [entity.name],
+      description: `${action.name} on ${entity.name}`,
+      sourceFile: action.sourceFile,
+      sourceLine: action.sourceLine,
+      sourceColumn: action.sourceColumn
+    };
+  });
+}
+function detectRouteCollisions(ir) {
+  const diagnostics = [];
+  const seen = new Map;
+  for (const mod of ir.modules) {
+    if (mod.name === SYNTHETIC_MODULE)
+      continue;
+    for (const router of mod.routers) {
+      for (const route of router.routes) {
+        seen.set(route.operationId, route);
+      }
+    }
+  }
+  const entityModule = ir.modules.find((m) => m.name === SYNTHETIC_MODULE);
+  if (entityModule) {
+    for (const router of entityModule.routers) {
+      for (const route of router.routes) {
+        const existing = seen.get(route.operationId);
+        if (existing) {
+          diagnostics.push({
+            code: "ENTITY_ROUTE_COLLISION",
+            severity: "error",
+            message: `Entity-generated operationId "${route.operationId}" collides with existing route at ${existing.sourceFile}:${existing.sourceLine}`,
+            ...route
+          });
+        }
+        seen.set(route.operationId, route);
+      }
+    }
+  }
+  return diagnostics;
+}
+
 // src/validators/completeness-validator.ts
 var METHODS_WITHOUT_RESPONSE = new Set(["DELETE", "HEAD", "OPTIONS"]);
 var RESERVED_CTX_KEYS = new Set([
@@ -2424,13 +3057,19 @@ class Compiler {
     const moduleResult = await analyzers.module.analyze();
     const middlewareResult = await analyzers.middleware.analyze();
     const appResult = await analyzers.app.analyze();
+    const entityResult = await analyzers.entity.analyze();
     const depGraphResult = await analyzers.dependencyGraph.analyze();
     ir.env = envResult.env;
     ir.schemas = schemaResult.schemas;
     ir.modules = moduleResult.modules;
     ir.middleware = middlewareResult.middleware;
     ir.app = appResult.app;
+    ir.entities = entityResult.entities;
     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());
+    injectEntityRoutes(ir);
+    const collisionDiags = detectRouteCollisions(ir);
+    ir.diagnostics.push(...collisionDiags);
     return enrichSchemasWithModuleNames(ir);
   }
   async validate(ir) {
@@ -2443,6 +3082,7 @@ class Compiler {
   }
   async generate(ir) {
     const outputDir = this.config.compiler.outputDir;
+    await mkdir(resolve(outputDir), { recursive: true });
     await Promise.all(this.deps.generators.map((g) => g.generate(ir, outputDir)));
   }
   async compile() {
@@ -2469,6 +3109,7 @@ function createCompiler(config) {
       middleware: new MiddlewareAnalyzer(project, resolved),
       module: new ModuleAnalyzer(project, resolved),
       app: new AppAnalyzer(project, resolved),
+      entity: new EntityAnalyzer(project, resolved),
       dependencyGraph: new DependencyGraphAnalyzer(project, resolved)
     },
     validators: [
@@ -2680,7 +3321,7 @@ async function* typecheckWatch(options = {}) {
   const completionMarker = /Found \d+ error/;
   let buffer = "";
   const results = [];
-  let resolve = null;
+  let resolve2 = null;
   let done = false;
   const onData = (chunk) => {
     buffer += chunk.toString();
@@ -2688,14 +3329,14 @@ async function* typecheckWatch(options = {}) {
       const result = parseWatchBlock(buffer);
       buffer = "";
       results.push(result);
-      resolve?.();
+      resolve2?.();
     }
   };
   proc.stdout?.on("data", onData);
   proc.stderr?.on("data", onData);
   proc.on("close", () => {
     done = true;
-    resolve?.();
+    resolve2?.();
   });
   try {
     while (!done || results.length > 0) {
@@ -2704,7 +3345,7 @@ async function* typecheckWatch(options = {}) {
         yield next;
       } else if (!done) {
         await new Promise((r) => {
-          resolve = r;
+          resolve2 = r;
         });
       }
     }
@@ -2717,11 +3358,11 @@ async function typecheck(options = {}) {
   if (options.tsconfigPath) {
     args.push("--project", options.tsconfigPath);
   }
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     execFile("tsc", args, { cwd: process.cwd() }, (error, stdout, stderr) => {
       const output = stdout + stderr;
       const diagnostics = parseTscOutput(output);
-      resolve({
+      resolve2({
         success: !error,
         diagnostics
       });
@@ -2782,6 +3423,7 @@ export {
   isSchemaFile,
   isSchemaExpression,
   isFromImport,
+  injectEntityRoutes,
   hasErrors,
   getVariableNameForCall,
   getStringValue,
@@ -2799,6 +3441,7 @@ export {
   extractObjectLiteral,
   extractMethodSignatures,
   extractIdentifierNames,
+  detectRouteCollisions,
   defineConfig,
   createSchemaExecutor,
   createNamedSchemaRef,
@@ -2828,6 +3471,7 @@ export {
   ManifestGenerator,
   IncrementalCompiler,
   EnvAnalyzer,
+  EntityAnalyzer,
   DependencyGraphAnalyzer,
   CompletenessValidator,
   Compiler,