zeti-framework-backend 0.2.4

package/dist/chunk-KIOZSPU2.js

@@ -0,0 +1,690 @@
+// src/scripts/generate-registry.ts
+import path from "path";
+async function generateRegistry(options) {
+  const {
+    controllersPath,
+    indexPath,
+    startMarker = "// @CONTROLLERS_START",
+    endMarker = "// @CONTROLLERS_END",
+    outputMode = "inject"
+  } = options;
+  const glob = new Bun.Glob("**/*.ts");
+  const imports = [];
+  for await (const file2 of glob.scan({ cwd: controllersPath, absolute: true })) {
+    const name = path.basename(file2);
+    if (name === "index.ts" || name === "registry.ts") continue;
+    const relativePath = path.relative(path.dirname(indexPath), file2);
+    const importPath = relativePath.replace(/\\/g, "/").replace(/\.ts$/, "");
+    imports.push(`import "${importPath.startsWith(".") ? importPath : "./" + importPath}";`);
+  }
+  if (outputMode === "standalone") {
+    const content = `// Generated by zeti-framework. Do not edit.
+
+${imports.join("\n")}
+`;
+    const file2 = Bun.file(indexPath);
+    try {
+      if (await file2.exists()) {
+        const existing = await file2.text();
+        if (existing === content) {
+          console.log(`\u2705 Registry unchanged (${imports.length} controllers)`);
+          return;
+        }
+      }
+    } catch {
+    }
+    await Bun.write(indexPath, content);
+    console.log(`\u2705 Generated .zeti/registry.ts with ${imports.length} controller imports`);
+    return;
+  }
+  const file = Bun.file(indexPath);
+  const indexContent = await file.exists() ? await file.text() : "";
+  const generatedBlock = `${startMarker}
+${imports.join("\n")}
+${endMarker}`;
+  let newContent;
+  if (indexContent.includes(startMarker)) {
+    const regex = new RegExp(`${startMarker}[\\s\\S]*?${endMarker}`, "g");
+    newContent = indexContent.replace(regex, generatedBlock);
+  } else {
+    newContent = indexContent + (indexContent ? "\n\n" : "") + generatedBlock;
+  }
+  if (newContent !== indexContent) {
+    await Bun.write(indexPath, newContent);
+    console.log(`\u2705 Injected ${imports.length} controller imports into ${indexPath}`);
+  } else {
+    console.log(`\u2705 Registry unchanged (${imports.length} controllers)`);
+  }
+}
+
+// src/scripts/generate-swagger-types.ts
+import path2 from "path";
+function splitUnionType(typeStr) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (let i = 0; i < typeStr.length; i++) {
+    const char = typeStr[i];
+    if (char === "<" || char === "{" || char === "[" || char === "(") depth++;
+    else if (char === ">" || char === "}" || char === "]" || char === ")") depth--;
+    else if (char === "|" && depth === 0) {
+      if (current.trim()) parts.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts;
+}
+function typeToZodSchemaWithRefs(typeStr, typeDefinitions, namedSchemas, depth = 0) {
+  if (depth > 10) return "z.any()";
+  typeStr = typeStr.trim();
+  const promiseMatch = typeStr.match(/^Promise<(.+)>$/);
+  if (promiseMatch) {
+    typeStr = promiseMatch[1].trim();
+  }
+  if (typeStr === "string") return "z.string()";
+  if (typeStr === "number") return "z.number()";
+  if (typeStr === "boolean") return "z.boolean()";
+  if (typeStr === "null") return "z.null()";
+  if (typeStr === "undefined") return "z.undefined()";
+  if (typeStr === "any") return "z.any()";
+  if (typeStr === "unknown") return "z.unknown()";
+  if (typeStr === "void") return "z.void()";
+  if (typeStr === "Date") return "z.date()";
+  const stringLiteralMatch = typeStr.match(/^["'](.+)["']$/);
+  if (stringLiteralMatch) {
+    return `z.literal("${stringLiteralMatch[1]}")`;
+  }
+  if (/^\d+$/.test(typeStr)) {
+    return `z.literal(${typeStr})`;
+  }
+  const arrayNamedMatch = typeStr.match(/^(\w+)\[\]$/);
+  if (arrayNamedMatch) {
+    const itemType = arrayNamedMatch[1];
+    if (typeDefinitions.has(itemType)) {
+      if (!namedSchemas.has(itemType)) {
+        const typeDef = typeDefinitions.get(itemType);
+        namedSchemas.set(itemType, typeToZodSchemaWithRefs(typeDef, typeDefinitions, namedSchemas, depth + 1));
+      }
+      return `z.array(namedSchemas.${itemType})`;
+    }
+    return `z.array(${typeToZodSchemaWithRefs(itemType, typeDefinitions, namedSchemas, depth + 1)})`;
+  }
+  const arrayGenericMatch = typeStr.match(/^Array<(.+)>$/);
+  if (arrayGenericMatch) {
+    const itemType = arrayGenericMatch[1].trim();
+    if (typeDefinitions.has(itemType)) {
+      if (!namedSchemas.has(itemType)) {
+        const typeDef = typeDefinitions.get(itemType);
+        namedSchemas.set(itemType, typeToZodSchemaWithRefs(typeDef, typeDefinitions, namedSchemas, depth + 1));
+      }
+      return `z.array(namedSchemas.${itemType})`;
+    }
+    return `z.array(${typeToZodSchemaWithRefs(itemType, typeDefinitions, namedSchemas, depth + 1)})`;
+  }
+  if (/^[A-Z]\w*$/.test(typeStr) && typeDefinitions.has(typeStr)) {
+    if (!namedSchemas.has(typeStr)) {
+      const typeDef = typeDefinitions.get(typeStr);
+      namedSchemas.set(typeStr, typeToZodSchemaWithRefs(typeDef, typeDefinitions, namedSchemas, depth + 1));
+    }
+    return `namedSchemas.${typeStr}`;
+  }
+  if (typeStr.startsWith("{") && typeStr.endsWith("}")) {
+    const inner = typeStr.slice(1, -1).trim();
+    if (!inner) return "z.object({})";
+    const props = [];
+    let currentDepth = 0;
+    let current = "";
+    let inString = false;
+    let stringChar = "";
+    for (let i = 0; i < inner.length; i++) {
+      const char = inner[i];
+      if (!inString && (char === '"' || char === "'" || char === "`")) {
+        inString = true;
+        stringChar = char;
+        current += char;
+      } else if (inString && char === stringChar && inner[i - 1] !== "\\") {
+        inString = false;
+        current += char;
+      } else if (!inString) {
+        if (char === "{" || char === "<" || char === "[" || char === "(") currentDepth++;
+        else if (char === "}" || char === ">" || char === "]" || char === ")") currentDepth--;
+        if ((char === "," || char === ";") && currentDepth === 0) {
+          if (current.trim()) props.push(current.trim());
+          current = "";
+        } else {
+          current += char;
+        }
+      } else {
+        current += char;
+      }
+    }
+    if (current.trim()) props.push(current.trim());
+    const zodProps = props.map((prop) => {
+      let colonIndex = -1;
+      let propDepth = 0;
+      for (let i = 0; i < prop.length; i++) {
+        const char = prop[i];
+        if (char === "<" || char === "{" || char === "[") propDepth++;
+        else if (char === ">" || char === "}" || char === "]") propDepth--;
+        else if (char === ":" && propDepth === 0) {
+          colonIndex = i;
+          break;
+        }
+      }
+      if (colonIndex === -1) return null;
+      let key = prop.slice(0, colonIndex).trim();
+      const value = prop.slice(colonIndex + 1).trim();
+      const isOptional = key.endsWith("?");
+      if (isOptional) key = key.slice(0, -1);
+      const zodType = typeToZodSchemaWithRefs(value, typeDefinitions, namedSchemas, depth + 1);
+      return `${key}: ${isOptional ? `${zodType}.optional()` : zodType}`;
+    }).filter(Boolean);
+    return `z.object({ ${zodProps.join(", ")} })`;
+  }
+  if (typeStr.includes("|") && !typeStr.includes("{")) {
+    const types = splitUnionType(typeStr).map((t) => typeToZodSchemaWithRefs(t.trim(), typeDefinitions, namedSchemas, depth + 1));
+    if (types.length === 2 && types.includes("z.undefined()")) {
+      const other = types.find((t) => t !== "z.undefined()");
+      return `${other}.optional()`;
+    }
+    if (types.length === 2 && types.includes("z.null()")) {
+      const other = types.find((t) => t !== "z.null()");
+      return `${other}.nullable()`;
+    }
+    return `z.union([${types.join(", ")}])`;
+  }
+  if (/^[A-Z]\w*$/.test(typeStr)) {
+    return "z.any()";
+  }
+  return "z.any()";
+}
+function extractTypeDefinitions(content) {
+  const types = /* @__PURE__ */ new Map();
+  const cleanContent = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
+  const typeRegex = /(?:export\s+)?(?:type|interface)\s+(\w+)\s*=?\s*\{/g;
+  let match;
+  while ((match = typeRegex.exec(cleanContent)) !== null) {
+    const name = match[1];
+    const startIndex = match.index + match[0].length - 1;
+    let depth = 1;
+    let endIndex = startIndex + 1;
+    while (depth > 0 && endIndex < cleanContent.length) {
+      const char = cleanContent[endIndex];
+      if (char === "{") depth++;
+      else if (char === "}") depth--;
+      endIndex++;
+    }
+    const body = cleanContent.slice(startIndex, endIndex);
+    types.set(name, body);
+  }
+  return types;
+}
+function extractRoutes(content, typeDefinitions, namedSchemas) {
+  const routes = [];
+  const routeRegex = /(?:app\.)?(get|post|put|del|patch)\s*\(\s*["'`]([^"'`]+)["'`]/g;
+  let match;
+  while ((match = routeRegex.exec(content)) !== null) {
+    const [fullMatch, method, routePath] = match;
+    const afterMatch = content.slice(match.index + fullMatch.length, match.index + fullMatch.length + 2e3);
+    let returnType = "z.any()";
+    let schemaName;
+    const explicitTypeMatch = afterMatch.match(/route\s*:\s*async\s*\([^)]*\)\s*:\s*Promise\s*<([^>]+)>/);
+    if (explicitTypeMatch) {
+      const typeRef = explicitTypeMatch[1].trim();
+      if (typeDefinitions.has(typeRef)) {
+        if (!namedSchemas.has(typeRef)) {
+          const typeDef = typeDefinitions.get(typeRef);
+          namedSchemas.set(typeRef, typeToZodSchemaWithRefs(typeDef, typeDefinitions, namedSchemas));
+        }
+        returnType = `namedSchemas.${typeRef}`;
+        schemaName = typeRef;
+      } else {
+        returnType = typeToZodSchemaWithRefs(typeRef, typeDefinitions, namedSchemas);
+      }
+    } else {
+      const returnMatch = afterMatch.match(/return\s+(\{[^}]+\})/);
+      if (returnMatch) {
+        returnType = inferTypeFromValue(returnMatch[1]);
+      }
+    }
+    routes.push({
+      path: routePath,
+      method: method === "del" ? "delete" : method,
+      returnType,
+      schemaName,
+      hasFormData: content.includes("formData")
+    });
+  }
+  return routes;
+}
+function inferTypeFromValue(value) {
+  value = value.trim();
+  if (value.startsWith("{") && value.endsWith("}")) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner) return "z.object({})";
+    const props = [];
+    const propRegex = /(\w+)\s*:\s*("[^"]*"|'[^']*'|`[^`]*`|\d+|true|false|null|\{[^}]*\}|\[[^\]]*\])/g;
+    let propMatch;
+    while ((propMatch = propRegex.exec(inner)) !== null) {
+      const [, key, val] = propMatch;
+      const zodType = inferTypeFromValue(val);
+      props.push(`${key}: ${zodType}`);
+    }
+    if (props.length > 0) {
+      return `z.object({ ${props.join(", ")} })`;
+    }
+  }
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'") || value.startsWith("`") && value.endsWith("`")) {
+    return "z.string()";
+  }
+  if (/^\d+(\.\d+)?$/.test(value)) {
+    return "z.number()";
+  }
+  if (value === "true" || value === "false") {
+    return "z.boolean()";
+  }
+  if (value === "null") {
+    return "z.null()";
+  }
+  if (value.startsWith("[") && value.endsWith("]")) {
+    return "z.array(z.any())";
+  }
+  return "z.any()";
+}
+async function generateSwaggerTypes(options) {
+  const { controllersPath, outputPath } = options;
+  const routes = [];
+  const namedSchemas = /* @__PURE__ */ new Map();
+  const glob = new Bun.Glob("**/*.ts");
+  const files = [];
+  for await (const file of glob.scan({ cwd: controllersPath, absolute: true })) {
+    const name = path2.basename(file);
+    if (name !== "index.ts" && name !== "registry.ts") {
+      files.push(file);
+    }
+  }
+  await Promise.all(files.map(async (filePath) => {
+    const file = Bun.file(filePath);
+    const content = await file.text();
+    const typeDefinitions = extractTypeDefinitions(content);
+    for (const [typeName, typeDef] of typeDefinitions) {
+      if (!namedSchemas.has(typeName)) {
+        const zodSchema = typeToZodSchemaWithRefs(typeDef, typeDefinitions, namedSchemas);
+        namedSchemas.set(typeName, zodSchema);
+      }
+    }
+    const fileRoutes = extractRoutes(content, typeDefinitions, namedSchemas);
+    routes.push(...fileRoutes);
+  }));
+  await writeOutput(outputPath, routes, namedSchemas);
+}
+function sortSchemasByDependency(schemas) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function getDependencies(schema) {
+    const deps = [];
+    const refMatches = schema.matchAll(/(?:namedSchemas\.|_)([A-Z]\w*)/g);
+    for (const match of refMatches) {
+      if (schemas.has(match[1])) {
+        deps.push(match[1]);
+      }
+    }
+    return deps;
+  }
+  function visit(name) {
+    if (visited.has(name)) return;
+    if (visiting.has(name)) return;
+    visiting.add(name);
+    const schema = schemas.get(name);
+    if (schema) {
+      for (const dep of getDependencies(schema)) {
+        visit(dep);
+      }
+    }
+    visiting.delete(name);
+    visited.add(name);
+    sorted.push(name);
+  }
+  for (const name of schemas.keys()) {
+    visit(name);
+  }
+  return sorted;
+}
+async function writeOutput(outputPath, routes, namedSchemas) {
+  const namedSchemasEntries = Array.from(namedSchemas.entries());
+  const sortedNames = sortSchemasByDependency(namedSchemas);
+  const schemaDeclarations = sortedNames.map((name) => {
+    const schema = namedSchemas.get(name);
+    const fixedSchema = schema.replace(/namedSchemas\.([A-Z]\w*)/g, "_$1");
+    return `const _${name} = ${fixedSchema};`;
+  }).join("\n");
+  const namedSchemasOutput = namedSchemasEntries.length > 0 ? `export const namedSchemas = {
+${sortedNames.map((name) => `  ${name}: _${name},`).join("\n")}
+} as const;
+
+` : `export const namedSchemas = {} as const;
+
+`;
+  const routeSchemasOutput = routes.map((r) => {
+    const hasFormDataStr = r.hasFormData ? ", hasFormData: true" : "";
+    if (r.schemaName) {
+      return `  "${r.path}": { "${r.method}": { schema: _${r.schemaName}, ref: "${r.schemaName}"${hasFormDataStr} } },`;
+    }
+    const fixedReturnType = r.returnType.replace(/namedSchemas\.([A-Z]\w*)/g, "_$1");
+    return `  "${r.path}": { "${r.method}": { schema: ${fixedReturnType}, ref: null${hasFormDataStr} } },`;
+  }).join("\n");
+  const output = `// Auto-generated by @zeti/framework/scripts
+// Do not edit manually
+
+import { z } from "zod";
+
+${schemaDeclarations}
+
+${namedSchemasOutput}export const routeResponseSchemas: Record<string, Record<string, { schema: z.ZodTypeAny; ref: string | null; hasFormData?: boolean }>> = {
+${routeSchemasOutput}
+};
+`;
+  const file = Bun.file(outputPath);
+  try {
+    if (await file.exists()) {
+      const existing = await file.text();
+      if (existing === output) {
+        console.log(`\u2705 Response schemas unchanged (${routes.length} routes)`);
+        return;
+      }
+    }
+  } catch {
+  }
+  await Bun.write(outputPath, output);
+  console.log(`\u2705 Generated response schemas for ${routes.length} routes (${namedSchemasEntries.length} named schemas)`);
+}
+
+// src/scripts/run-prebuild.ts
+import path3 from "path";
+var CACHE_FILE = ".zeti/.prebuild-cache.json";
+async function getFileHash(filePath) {
+  try {
+    const file = Bun.file(filePath);
+    const stat = await file.stat();
+    return `${stat.mtime}-${stat.size}`;
+  } catch {
+    return "";
+  }
+}
+async function loadCache(projectRoot) {
+  const cachePath = path3.join(projectRoot, CACHE_FILE);
+  try {
+    const file = Bun.file(cachePath);
+    if (await file.exists()) {
+      const data = await file.json();
+      return new Map(Object.entries(data));
+    }
+  } catch {
+  }
+  return /* @__PURE__ */ new Map();
+}
+async function saveCache(projectRoot, cache) {
+  const cachePath = path3.join(projectRoot, CACHE_FILE);
+  try {
+    await Bun.write(cachePath, JSON.stringify(Object.fromEntries(cache)));
+  } catch {
+  }
+}
+async function hasChanges(controllersPath, cache) {
+  const newCache = /* @__PURE__ */ new Map();
+  let changed = false;
+  const dirFile = Bun.file(controllersPath);
+  try {
+    await dirFile.stat();
+  } catch {
+    return { changed: cache.size > 0, newCache };
+  }
+  const glob = new Bun.Glob("**/*.ts");
+  const files = [];
+  for await (const file of glob.scan({ cwd: controllersPath, absolute: true })) {
+    const name = path3.basename(file);
+    if (name !== "index.ts" && name !== "registry.ts") {
+      files.push(file);
+    }
+  }
+  await Promise.all(files.map(async (file) => {
+    const hash = await getFileHash(file);
+    newCache.set(file, hash);
+    if (cache.get(file) !== hash) {
+      changed = true;
+    }
+  }));
+  for (const file of cache.keys()) {
+    if (!newCache.has(file)) {
+      changed = true;
+      break;
+    }
+  }
+  return { changed, newCache };
+}
+var APP_FILE_CONTENT = `import { createAppProxy, getRedisClient, hasRedis } from 'zeti-framework';
+import type { PrismaClient } from '@prisma/client';
+import type { Redis } from 'ioredis';
+
+export const app = createAppProxy<PrismaClient, any>();
+
+/**
+ * Cliente Redis singleton via Proxy.
+ * Dispon\xEDvel ap\xF3s configura\xE7\xE3o em startZeti({ redis: {...} }).
+ * 
+ * @example
+ * import { app, redis } from '@zeti/app';
+ * 
+ * await redis.set('key', 'value');
+ * const value = await redis.get('key');
+ */
+export const redis: Redis = new Proxy({} as Redis, {
+  get(_, prop) {
+    if (!hasRedis()) {
+      throw new Error('[Redis] Not configured. Add redis config to startZeti()');
+    }
+    const client = getRedisClient();
+    const value = (client as any)[prop];
+    return typeof value === 'function' ? value.bind(client) : value;
+  }
+});
+
+export const { get, post, put, del, patch, createMiddleware } = app;
+`;
+var PRISMA_HELPERS_CONTENT = `/**
+ * Helpers tipados para o PrismaClient do projeto
+ * 
+ * Gerado automaticamente pelo zeti-framework.
+ * Use estes helpers em middlewares e outros lugares onde
+ * o tipo do PrismaClient n\xE3o \xE9 inferido automaticamente.
+ */
+
+import type { Context, Next } from 'hono';
+import type { PrismaClient } from '@prisma/client';
+import { 
+  getPrismaClient as _getPrismaClient, 
+  getSpecialDatabase as _getSpecialDatabase,
+  createMiddleware as _createMiddleware,
+} from 'zeti-framework';
+import type { MiddlewareHandler as _MiddlewareHandler } from 'zeti-framework';
+
+// Re-exporta o tipo do PrismaClient
+export type { PrismaClient };
+export type AppPrismaClient = PrismaClient;
+
+/**
+ * Handler de middleware tipado com o PrismaClient do projeto.
+ */
+export type MiddlewareHandler = _MiddlewareHandler<PrismaClient>;
+
+/**
+ * Cria um middleware com o db tipado automaticamente.
+ * 
+ * @example
+ * import { createMiddleware } from '.zeti/prisma';
+ * 
+ * export const authMiddleware = createMiddleware(async (c, next, db) => {
+ *   // db j\xE1 vem tipado com os models do schema.prisma
+ *   const user = await db.user.findUnique({
+ *     where: { id: c.req.header('x-user-id') }
+ *   });
+ *   
+ *   if (!user) {
+ *     return c.json({ error: 'Unauthorized' }, 401);
+ *   }
+ *   
+ *   c.set('user', user);
+ *   await next();
+ * });
+ */
+export function createMiddleware(
+  handler: MiddlewareHandler
+): (c: Context, next: Next) => Promise<void | Response> {
+  return _createMiddleware<PrismaClient>(handler);
+}
+
+/**
+ * Cria uma factory de middleware com db tipado.
+ * 
+ * @example
+ * import { createMiddlewareFactory } from '.zeti/prisma';
+ * 
+ * const requirePermission = createMiddlewareFactory(
+ *   (permissions: string[]) => async (c, next, db) => {
+ *     const user = c.get('user');
+ *     const userPerms = await db.permission.findMany({
+ *       where: { userId: user.id }
+ *     });
+ *     
+ *     if (!permissions.every(p => userPerms.some(up => up.name === p))) {
+ *       return c.json({ error: 'Forbidden' }, 403);
+ *     }
+ *     
+ *     await next();
+ *   }
+ * );
+ * 
+ * // Uso:
+ * app.use('/admin/*', requirePermission(['admin:read']));
+ */
+export function createMiddlewareFactory<T extends any[]>(
+  factory: (...args: T) => MiddlewareHandler
+): (...args: T) => (c: Context, next: Next) => Promise<void | Response> {
+  return (...args: T) => _createMiddleware<PrismaClient>(factory(...args));
+}
+
+/**
+ * Retorna o PrismaClient com tipagem correta do projeto
+ * 
+ * @param tenantId - ID do tenant (opcional, usa o padr\xE3o se n\xE3o fornecido)
+ * @returns PrismaClient tipado com os models do schema.prisma
+ * 
+ * @example
+ * const db = getPrismaClient();
+ * const users = await db.user.findMany(); // \u2705 Tipado corretamente
+ */
+export function getPrismaClient(tenantId?: string): PrismaClient {
+  return _getPrismaClient<PrismaClient>(tenantId);
+}
+
+/**
+ * Retorna um database especial com tipagem correta
+ * 
+ * @param key - Chave do database especial configurado em specialDatabases
+ * @returns PrismaClient tipado
+ * 
+ * @example
+ * const adminDb = getSpecialDatabase('admin');
+ * const logs = await adminDb.auditLog.findMany();
+ */
+export function getSpecialDatabase(key: string): PrismaClient {
+  return _getSpecialDatabase<PrismaClient>(key);
+}
+`;
+async function ensureAppFile(zetiDir, prismaImport) {
+  const appPath = path3.join(zetiDir, "app.ts");
+  const expectedContent = APP_FILE_CONTENT.replace("@prisma/client", prismaImport);
+  try {
+    const file = Bun.file(appPath);
+    if (await file.exists()) {
+      const currentContent = await file.text();
+      if (currentContent === expectedContent) {
+        return false;
+      }
+    }
+  } catch {
+  }
+  await Bun.write(appPath, expectedContent);
+  return true;
+}
+async function ensurePrismaHelpersFile(zetiDir, prismaImport) {
+  const helpersPath = path3.join(zetiDir, "prisma.ts");
+  const expectedContent = PRISMA_HELPERS_CONTENT.replace(/@prisma\/client/g, prismaImport);
+  try {
+    const file = Bun.file(helpersPath);
+    if (await file.exists()) {
+      const currentContent = await file.text();
+      if (currentContent === expectedContent) {
+        return false;
+      }
+    }
+  } catch {
+  }
+  await Bun.write(helpersPath, expectedContent);
+  return true;
+}
+async function runPrebuild(options = {}) {
+  const startTime = Bun.nanoseconds();
+  const projectRoot = path3.resolve(options.projectRoot || process.cwd());
+  const zetiConfig = options.zetiConfig;
+  const controllersPath = path3.join(
+    projectRoot,
+    options.controllersPath || "src/controllers"
+  );
+  const zetiDir = path3.join(projectRoot, ".zeti");
+  const registryPath = path3.join(zetiDir, "registry.ts");
+  const swaggerOutputPath = options.swaggerOutputPath || (zetiConfig?.swagger?.outputPath ? path3.isAbsolute(zetiConfig.swagger.outputPath) ? zetiConfig.swagger.outputPath : path3.join(projectRoot, zetiConfig.swagger.outputPath) : path3.join(zetiDir, "generated/swagger-schemas.ts"));
+  const fs = await import("fs");
+  if (!fs.existsSync(zetiDir)) {
+    fs.mkdirSync(zetiDir, { recursive: true });
+    console.log("\u{1F4C1} [zeti] Created .zeti directory");
+  }
+  const prismaImport = options.prismaImport || "@prisma/client";
+  const [appChanged, prismaHelpersChanged] = await Promise.all([
+    ensureAppFile(zetiDir, prismaImport),
+    ensurePrismaHelpersFile(zetiDir, prismaImport)
+  ]);
+  const cache = await loadCache(projectRoot);
+  const { changed, newCache } = await hasChanges(controllersPath, cache);
+  if (!options.force && !changed && !appChanged && !prismaHelpersChanged) {
+    const elapsed2 = ((Bun.nanoseconds() - startTime) / 1e6).toFixed(0);
+    console.log(`\u26A1 [zeti] No changes detected (${elapsed2}ms)`);
+    return;
+  }
+  console.log("\u{1F504} [zeti] Generating files...");
+  await Promise.all([
+    generateRegistry({
+      controllersPath,
+      indexPath: registryPath,
+      outputMode: "standalone"
+    }),
+    generateSwaggerTypes({
+      controllersPath,
+      outputPath: swaggerOutputPath
+    })
+  ]);
+  await saveCache(projectRoot, newCache);
+  const elapsed = ((Bun.nanoseconds() - startTime) / 1e6).toFixed(0);
+  console.log(`\u2705 [zeti] Prebuild complete! (${elapsed}ms)`);
+}
+
+export {
+  generateRegistry,
+  generateSwaggerTypes,
+  runPrebuild
+};
+//# sourceMappingURL=chunk-KIOZSPU2.js.map