@boon4681/giri 0.0.2-alpha-8 → 0.0.3-alpha-1

package/dist/index.d.ts

@@ -82,6 +82,12 @@ interface BuildGiriAppOptions {
     services?: Services;
     /** Files that changed since last build — only these are purged from require.cache before loading. */
     dirty?: Set<string>;
+    /** Defer route-module evaluation until the adapter first reads its runtime fields. */
+    lazy?: boolean;
+    /** The caller owns a persistent TypeScript loader for lazy route evaluation. */
+    loaderRegistered?: boolean;
+    /** The caller owns a persistent project-alias resolver for lazy route evaluation. */
+    aliasResolverRegistered?: boolean;
 }
 interface BuiltGiriApp<App> {
     app: App;

package/dist/index.js

@@ -45,13 +45,7 @@ var init_es5 = __esm({
 });
 
 // src/generator/schema/program.ts
-function leanOptions(options) {
-  return {
-    ...options,
-    types: []
-  };
-}
-function createSchemaProgram(paths, routeFiles, programOptions = {}) {
+function createSchemaProgram(paths, routeFiles) {
   let options = { ...DEFAULT_OPTIONS };
   const configPath = import_typescript2.default.findConfigFile(paths.cwd, import_typescript2.default.sys.fileExists, "tsconfig.json");
   if (configPath) {
@@ -64,9 +58,6 @@ function createSchemaProgram(paths, routeFiles, programOptions = {}) {
       options = { ...parsed.options, noEmit: true };
     }
   }
-  if (programOptions.lean) {
-    options = leanOptions(options);
-  }
   return import_typescript2.default.createProgram(routeFiles, options);
 }
 var import_typescript2, DEFAULT_OPTIONS;
@@ -1108,8 +1099,11 @@ async function buildGiriApp(config, options = {}) {
   const routes = await scanRoutes(paths.routesDir);
   const app = config.adapter.createApp();
   ensureGiriAliasResolver(paths.outDir);
-  const { unregister } = await safeRegister();
-  const unregisterAliasResolver = registerAliasResolver(config.alias, paths.cwd);
+  if (options.lazy && (!options.loaderRegistered || !options.aliasResolverRegistered)) {
+    throw new Error("Lazy route loading requires persistent loader and alias registrations.");
+  }
+  const loader = options.loaderRegistered ? void 0 : await safeRegister();
+  const unregisterAliasResolver = options.aliasResolverRegistered ? void 0 : registerAliasResolver(config.alias, paths.cwd);
   try {
     const dirty = options.dirty;
     const forceReload = dirty === void 0;
@@ -1121,7 +1115,7 @@ async function buildGiriApp(config, options = {}) {
       }
       return sharedCache.get(file);
     };
-    for (const route of routes) {
+    const runtimeFor = (route) => {
       const routeModule = loadModule(route.file, isDirty(route.file));
       if (typeof routeModule.handle !== "function") {
         throw new Error(`${route.file} must export a named handle function.`);
@@ -1130,7 +1124,7 @@ async function buildGiriApp(config, options = {}) {
         (file) => normalizeMiddleware(loadShared(file).middleware, file)
       );
       const verbMiddleware = normalizeMiddleware(routeModule.middleware, route.file);
-      config.adapter.register(app, {
+      return {
         method: route.method,
         path: route.path,
         handle: routeModule.handle,
@@ -1138,19 +1132,45 @@ async function buildGiriApp(config, options = {}) {
         input: routeInput(routeModule, route.file),
         services: options.services,
         cookieSecret: config.cookieSecret
+      };
+    };
+    for (const route of routes) {
+      if (!options.lazy) {
+        config.adapter.register(app, runtimeFor(route));
+        continue;
+      }
+      let runtime;
+      const getRuntime = () => {
+        runtime ??= runtimeFor(route);
+        return runtime;
+      };
+      config.adapter.register(app, {
+        method: route.method,
+        path: route.path,
+        get handle() {
+          return getRuntime().handle;
+        },
+        get middleware() {
+          return getRuntime().middleware;
+        },
+        get input() {
+          return getRuntime().input;
+        },
+        services: options.services,
+        cookieSecret: config.cookieSecret
       });
     }
   } finally {
-    unregisterAliasResolver();
-    unregister();
+    unregisterAliasResolver?.();
+    loader?.unregister();
   }
   return { app, routes, paths };
 }
 
 // src/generator/sync.ts
-var import_node_fs7 = require("fs");
-var import_promises3 = require("fs/promises");
-var import_node_path11 = require("path");
+var import_node_fs8 = require("fs");
+var import_promises4 = require("fs/promises");
+var import_node_path12 = require("path");
 
 // src/generator/app-types.ts
 var import_node_fs4 = require("fs");
@@ -2097,6 +2117,103 @@ async function writeTsConfig(paths, config) {
   });
 }
 
+// src/generator/cache.ts
+var import_node_crypto = require("crypto");
+var import_node_fs7 = require("fs");
+var import_promises3 = require("fs/promises");
+var import_node_path11 = require("path");
+var import_tinyglobby2 = require("tinyglobby");
+var CACHE_VERSION = 1;
+var SYNC_CACHE_NAME = ".sync-cache.json";
+function stableConfig(config) {
+  const alias = Object.entries(config.alias ?? {}).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => [key, Array.isArray(value) ? [...value] : value]);
+  return { alias, outDir: config.outDir ?? ".giri" };
+}
+async function syncFingerprint(config, paths) {
+  const outRelative = slash((0, import_node_path11.relative)(paths.cwd, paths.outDir));
+  const ignore = ["**/node_modules/**", "**/.git/**"];
+  if (outRelative && !outRelative.startsWith("..")) {
+    ignore.push(`${outRelative}/**`);
+  }
+  const files = await (0, import_tinyglobby2.glob)([
+    "src/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,json}",
+    "giri.config.{ts,js,mts,cts,mjs,cjs}",
+    "tsconfig*.json",
+    "package.json",
+    "package-lock.json",
+    "npm-shrinkwrap.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "bun.lock",
+    "bun.lockb"
+  ], {
+    cwd: paths.cwd,
+    absolute: false,
+    onlyFiles: true,
+    dot: true,
+    ignore
+  });
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  hash.update(JSON.stringify(stableConfig(config)));
+  for (const file of files.sort()) {
+    hash.update("\0");
+    hash.update(slash(file));
+    hash.update("\0");
+    hash.update(await (0, import_promises3.readFile)((0, import_node_path11.resolve)(paths.cwd, file)));
+  }
+  return hash.digest("hex");
+}
+function cachePath(paths) {
+  return (0, import_node_path11.join)(paths.outDir, SYNC_CACHE_NAME);
+}
+function serializePath(paths, file) {
+  return slash((0, import_node_path11.relative)(paths.cwd, file));
+}
+function deserializePath(paths, file) {
+  return slash((0, import_node_path11.resolve)(paths.cwd, file.split("/").join(import_node_path11.sep)));
+}
+function serializeMap(paths, values) {
+  return [...values].map(([file, value]) => [serializePath(paths, file), value]);
+}
+function deserializeMap(paths, values) {
+  return new Map(values.map(([file, value]) => [deserializePath(paths, file), value]));
+}
+async function readSyncCache(paths, fingerprint) {
+  const file = cachePath(paths);
+  if (!(0, import_node_fs7.existsSync)(file)) {
+    return void 0;
+  }
+  try {
+    const cache = JSON.parse(await (0, import_promises3.readFile)(file, "utf8"));
+    if (cache.version !== CACHE_VERSION || cache.fingerprint !== fingerprint) {
+      return void 0;
+    }
+    return {
+      responsesByFile: deserializeMap(paths, cache.data.responsesByFile),
+      inputsByFile: deserializeMap(paths, cache.data.inputsByFile),
+      securityByFile: deserializeMap(paths, cache.data.securityByFile),
+      hiddenFiles: new Set(cache.data.hiddenFiles.map((entry) => deserializePath(paths, entry))),
+      openapiByFile: deserializeMap(paths, cache.data.openapiByFile)
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function writeSyncCache(paths, fingerprint, data) {
+  const cache = {
+    version: CACHE_VERSION,
+    fingerprint,
+    data: {
+      responsesByFile: serializeMap(paths, data.responsesByFile),
+      inputsByFile: serializeMap(paths, data.inputsByFile),
+      securityByFile: serializeMap(paths, data.securityByFile),
+      hiddenFiles: [...data.hiddenFiles].map((file) => serializePath(paths, file)),
+      openapiByFile: serializeMap(paths, data.openapiByFile)
+    }
+  };
+  await writeJson(cachePath(paths), cache);
+}
+
 // src/generator/sync.ts
 async function typeFolders(paths, routes) {
   const verbsByDir = /* @__PURE__ */ new Map();
@@ -2123,57 +2240,17 @@ async function extractResponses(paths, routes) {
   try {
     const { createSchemaProgram: createSchemaProgram2, extractRouteResponses: extractRouteResponses2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
     const files = [...new Set(routes.map((route) => route.file))];
-    const appTypes = (0, import_node_path11.join)(paths.outDir, "types", "app.d.ts");
-    const roots = (0, import_node_fs7.existsSync)(appTypes) ? [...files, appTypes] : files;
-    const program = createSchemaProgram2(paths, roots, { lean: true });
-    const fallbackFiles = [];
+    const appTypes = (0, import_node_path12.join)(paths.outDir, "types", "app.d.ts");
+    const roots = (0, import_node_fs8.existsSync)(appTypes) ? [...files, appTypes] : files;
+    const program = createSchemaProgram2(paths, roots);
     for (const file of files) {
-      const responses = extractRouteResponses2(program, file);
-      byFile.set(file, responses);
-      if (hasLooseResponseSchema(responses)) {
-        fallbackFiles.push(file);
-      }
-    }
-    if (fallbackFiles.length > 0) {
-      const fullProgram = createSchemaProgram2(
-        paths,
-        (0, import_node_fs7.existsSync)(appTypes) ? [...fallbackFiles, appTypes] : fallbackFiles
-      );
-      for (const file of fallbackFiles) {
-        byFile.set(file, extractRouteResponses2(fullProgram, file));
-      }
+      byFile.set(file, extractRouteResponses2(program, file));
     }
   } catch (error) {
     console.warn(`giri: skipped response schema generation (${error.message}).`);
   }
   return byFile;
 }
-function isLooseSchema(value) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const schema = value;
-  const keys = Object.keys(schema);
-  if (keys.length === 0) {
-    return true;
-  }
-  if (typeof schema.$ref === "string") {
-    return false;
-  }
-  if (Array.isArray(schema.anyOf) && schema.anyOf.some(isLooseSchema)) {
-    return true;
-  }
-  if (schema.items && isLooseSchema(schema.items)) {
-    return true;
-  }
-  if (schema.properties && typeof schema.properties === "object") {
-    return Object.values(schema.properties).some(isLooseSchema);
-  }
-  return false;
-}
-function hasLooseResponseSchema(responses) {
-  return responses.responses.some((response) => isLooseSchema(response.schema));
-}
 async function extractMeta(config, paths, routes) {
   const inputsByFile = /* @__PURE__ */ new Map();
   const securityByFile = /* @__PURE__ */ new Map();
@@ -2206,28 +2283,44 @@ async function extractMeta(config, paths, routes) {
 async function syncProject(config, options = {}) {
   const paths = resolveGiriPaths(config, options.cwd);
   assertSafeOutDir(paths);
-  const hadOutDir = (0, import_node_fs7.existsSync)(paths.outDir);
+  const hadOutDir = (0, import_node_fs8.existsSync)(paths.outDir);
   const routes = await scanRoutes(paths.routesDir);
   const folders = await typeFolders(paths, routes);
-  await (0, import_promises3.mkdir)(paths.outDir, { recursive: true });
+  const fingerprint = await syncFingerprint(config, paths);
+  const cached = await readSyncCache(paths, fingerprint);
+  const generatedFiles = [
+    (0, import_node_path12.join)(paths.outDir, "tsconfig.json"),
+    (0, import_node_path12.join)(paths.outDir, "manifest.json"),
+    (0, import_node_path12.join)(paths.outDir, "openapi.json"),
+    (0, import_node_path12.join)(paths.outDir, "routes.d.ts"),
+    (0, import_node_path12.join)(paths.outDir, "types", "app.d.ts"),
+    ...folders.map((folder) => typeFilePath(paths, folder.dir))
+  ];
+  if (cached && generatedFiles.every(import_node_fs8.existsSync)) {
+    return { paths, routes, folders, data: cached };
+  }
+  await (0, import_promises4.mkdir)(paths.outDir, { recursive: true });
   await writeParamTypes(paths, folders);
   await writeRouteTypes(paths, routes);
   await writeAppTypes(paths);
   await writeTsConfig(paths, config);
-  const responsesByFile = await extractResponses(paths, routes);
-  const { inputsByFile, securityByFile, hiddenFiles, openapiByFile } = await extractMeta(config, paths, routes);
-  const data = { responsesByFile, inputsByFile, securityByFile, hiddenFiles, openapiByFile };
+  const data = cached ?? {
+    responsesByFile: await extractResponses(paths, routes),
+    ...await extractMeta(config, paths, routes)
+  };
   await writeManifest(paths, routes, data);
   await writeOpenApi(paths, routes, data);
+  await writeSyncCache(paths, fingerprint, data);
   if (hadOutDir) {
     await pruneDir(
       paths.outDir,
       /* @__PURE__ */ new Set([
-        (0, import_node_path11.join)(paths.outDir, "tsconfig.json"),
-        (0, import_node_path11.join)(paths.outDir, "manifest.json"),
-        (0, import_node_path11.join)(paths.outDir, "openapi.json"),
-        (0, import_node_path11.join)(paths.outDir, "routes.d.ts"),
-        (0, import_node_path11.join)(paths.outDir, "types", "app.d.ts"),
+        (0, import_node_path12.join)(paths.outDir, "tsconfig.json"),
+        (0, import_node_path12.join)(paths.outDir, "manifest.json"),
+        (0, import_node_path12.join)(paths.outDir, "openapi.json"),
+        (0, import_node_path12.join)(paths.outDir, "routes.d.ts"),
+        (0, import_node_path12.join)(paths.outDir, SYNC_CACHE_NAME),
+        (0, import_node_path12.join)(paths.outDir, "types", "app.d.ts"),
         ...folders.map((folder) => typeFilePath(paths, folder.dir))
       ])
     );
@@ -2236,27 +2329,33 @@ async function syncProject(config, options = {}) {
 }
 
 // src/generator/watch.ts
-var import_node_fs8 = require("fs");
+var import_node_fs10 = require("fs");
+var import_node_path15 = require("path");
+
+// src/loader/import-graph.ts
+var import_node_fs9 = require("fs");
 var import_node_path13 = require("path");
+var import_typescript5 = __toESM(require("typescript"));
+var import_tinyglobby3 = require("tinyglobby");
 
 // src/loader/module-loader.ts
-var import_node_path12 = require("path");
+var import_node_path14 = require("path");
 
 // src/lifecycle.ts
-var import_node_fs9 = require("fs");
-var import_node_path14 = require("path");
+var import_node_fs11 = require("fs");
+var import_node_path16 = require("path");
 var MAIN_EXTENSIONS2 = ["ts", "tsx", "mts", "cts", "js", "jsx", "mjs", "cjs"];
 function resolveMainFile(cwd) {
   for (const ext of MAIN_EXTENSIONS2) {
-    const file = (0, import_node_path14.join)(cwd, "src", `main.${ext}`);
-    if ((0, import_node_fs9.existsSync)(file)) {
+    const file = (0, import_node_path16.join)(cwd, "src", `main.${ext}`);
+    if ((0, import_node_fs11.existsSync)(file)) {
       return file;
     }
   }
   return void 0;
 }
 async function loadLifecycle(cwd = process.cwd()) {
-  const file = resolveMainFile((0, import_node_path14.resolve)(cwd));
+  const file = resolveMainFile((0, import_node_path16.resolve)(cwd));
   if (!file) {
     return {};
   }