silgi 0.24.15 → 0.24.17

package/dist/cli/scan/prepareSchema.mjs

@@ -0,0 +1,177 @@
+import { isAbsolute } from 'pathe';
+import { relativeWithDot } from 'silgi/kit';
+import { generateTypes, resolveSchema } from 'untyped';
+
+async function prepareSchema(silgi) {
+  const importItems = {
+    "silgi/types": {
+      import: [
+        {
+          name: "URIsTypes",
+          type: true,
+          key: "URIsTypes"
+        },
+        {
+          name: "Namespaces",
+          type: true,
+          key: "Namespaces"
+        },
+        {
+          name: "SilgiRuntimeContext",
+          type: true,
+          key: "SilgiRuntimeContext"
+        }
+      ],
+      from: "silgi/types"
+    },
+    "silgi/scan": {
+      import: [{
+        key: "modulesURIs",
+        name: "modulesURIs",
+        type: false
+      }],
+      from: relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/scan.ts`)
+    }
+  };
+  const data = {
+    importItems,
+    customImports: [],
+    options: [],
+    contexts: [],
+    actions: [],
+    shareds: [
+      {
+        key: "modulesURIs",
+        value: "{ modulesURIs: typeof modulesURIs }"
+      }
+    ],
+    events: [],
+    hooks: [],
+    runtimeHooks: [],
+    runtimeOptions: [],
+    methods: [],
+    routeRules: [],
+    routeRulesConfig: []
+  };
+  await silgi.callHook("prepare:schema.ts", data);
+  relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/core.ts`);
+  const silgiScanTS = relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/scan.ts`);
+  let addSilgiContext = false;
+  const importsContent = [
+    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
+      const path = isAbsolute(from) ? relativeWithDot(silgi.options.build.typesDir, from) : from;
+      if (silgi.options.typescript.removeFileExtension) {
+        from = from.replace(/\.(js|ts|mjs|cjs|jsx|tsx)$/, "");
+      }
+      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
+    }),
+    "",
+    ...data.customImports,
+    ""
+  ];
+  const importData = [
+    "interface InferredNamespaces {",
+    ...(silgi.options.namespaces || []).map((key) => `  ${key}: string,`),
+    "}",
+    "",
+    `type SchemaExtends = Namespaces<typeof import('${silgiScanTS}')['schemas']>`,
+    "",
+    `type SilgiURIsMerge = URIsTypes<typeof import('${silgiScanTS}')['uris']>`,
+    "",
+    `type SilgiModuleContextExtends = ${data.contexts.length ? data.contexts.map(({ value }) => value).join(" & ") : "{}"}`,
+    "",
+    data.events.length ? `interface SilgiModuleEventsExtends extends ${data.events.map((item) => item.extends ? item.value : "").join(", ")} {
+      ${data.events.map((item) => {
+      if (item.isSilgiContext) {
+        addSilgiContext = true;
+      }
+      return !item.extends && !addSilgiContext ? `  ${item.key}: ${item.value}` : item.isSilgiContext ? " context: SilgiRuntimeContext" : "";
+    }).join(",\n")}
+}` : "interface SilgiModuleEventsExtends {}",
+    "",
+    `type RuntimeActionExtends = ${data.actions?.length ? data.actions.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    `type RuntimeMethodExtends = ${data.methods?.length ? data.methods.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    `type RuntimeRouteRulesExtends = ${data.routeRules?.length ? data.routeRules.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    `type RuntimeRouteRulesConfigExtends = ${data.routeRulesConfig?.length ? data.routeRulesConfig.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    `type SilgiModuleSharedExtends = ${data.shareds.length ? data.shareds.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    `type SilgiModuleOptionExtend = ${data.options?.length ? data.options.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    `type SilgiRuntimeOptionExtends = ${data.runtimeOptions?.length ? data.runtimeOptions.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    silgi.options.typescript.generateRuntimeConfigTypes ? generateTypes(
+      await resolveSchema(
+        {
+          ...Object.fromEntries(
+            Object.entries(silgi.options.runtimeConfig).filter(
+              ([key]) => !["app", "nitro", "nuxt"].includes(key)
+            )
+          )
+        }
+      ),
+      {
+        interfaceName: "SilgiRuntimeConfigExtends",
+        addExport: false,
+        addDefaults: false,
+        allowExtraKeys: false,
+        indentation: 0
+      }
+    ) : "",
+    "",
+    generateTypes(
+      await resolveSchema(
+        {
+          ...silgi.options.storages?.reduce((acc, key) => ({ ...acc, [key]: "" }), {}) || {},
+          // 'redis': {} -> 'redis': string
+          ...Object.entries(silgi.options.storage).map(([key]) => ({
+            [key]: ""
+          })).reduce((acc, obj) => ({ ...acc, ...obj }), {})
+        }
+      ),
+      {
+        interfaceName: "SilgiStorageBaseExtends",
+        addExport: false,
+        addDefaults: false,
+        allowExtraKeys: false,
+        indentation: 0
+      }
+    ),
+    "",
+    `type ModuleHooksExtend = ${data.hooks?.length ? data.hooks.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    `type SilgiRuntimeHooksExtends = ${data.runtimeHooks?.length ? data.runtimeHooks.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    "declare module 'silgi/types' {",
+    " interface FrameworkContext extends FrameworkContextExtends {}",
+    " interface SilgiSchema extends SchemaExtends {}",
+    " interface SilgiNamespaces extends InferredNamespaces {}",
+    " interface SilgiStorageBase extends SilgiStorageBaseExtends {}",
+    " interface SilgiURIs extends SilgiURIsMerge {}",
+    " interface SilgiRuntimeContext extends SilgiModuleContextExtends {}",
+    " interface SilgiEvents extends SilgiModuleEventsExtends {}",
+    " interface SilgiRuntimeSharedsExtend extends SilgiModuleSharedExtends {}",
+    " interface SilgiRuntimeActions extends RuntimeActionExtends {}",
+    " interface SilgiModuleOptions extends SilgiModuleOptionExtend {}",
+    " interface SilgiRuntimeOptions extends SilgiRuntimeOptionExtends {}",
+    " interface SilgiRuntimeHooks extends SilgiRuntimeHooksExtends {}",
+    " interface SilgiRuntimeConfig extends SilgiRuntimeConfigExtends {}",
+    " interface SilgiHooks extends ModuleHooksExtend {}",
+    " interface SilgiRuntimeMethods extends RuntimeMethodExtends {}",
+    " interface SilgiRuntimeRouteRules extends RuntimeRouteRulesExtends {}",
+    " interface SilgiRuntimeRouteRulesConfig extends RuntimeRouteRulesConfigExtends {}",
+    " interface SilgiCommands extends SilgiCommandsExtended {}",
+    "",
+    "}",
+    "",
+    "export {}"
+  ];
+  await silgi.callHook("after:prepare:schema.ts", importData);
+  importData.unshift(...importsContent);
+  return importData;
+}
+
+export { prepareSchema };

package/dist/cli/scan/prepareServerFiles.mjs

@@ -0,0 +1,119 @@
+import { defu } from 'defu';
+
+async function prepareServerFiles(silgi) {
+  const importItems = {
+    "silgi": {
+      import: [
+        { name: "createSilgi", key: "createSilgi" },
+        { name: "createShared", key: "createShared" }
+      ],
+      from: "silgi"
+    },
+    "silgi/types": {
+      import: [
+        { name: "SilgiRuntimeOptions", type: true, key: "SilgiRuntimeOptions" },
+        { name: "FrameworkContext", type: true, key: "FrameworkContext" }
+      ],
+      from: "silgi/types"
+    },
+    "#silgi/vfs": {
+      import: [],
+      from: "./vfs"
+    },
+    "configs.ts": {
+      import: [
+        {
+          name: "cliConfigs",
+          type: false,
+          key: "cliConfigs"
+        }
+      ],
+      from: "./configs.ts"
+    }
+  };
+  const scanned = {
+    uris: {},
+    services: [],
+    shareds: [
+      `createShared({
+        modulesURIs,
+      })`
+    ],
+    schemas: [],
+    modulesURIs: {},
+    customImports: [],
+    importItems
+  };
+  if (silgi.uris) {
+    defu(scanned.uris, silgi.uris);
+  }
+  if (silgi.modulesURIs) {
+    defu(scanned.modulesURIs, silgi.modulesURIs);
+  }
+  await silgi.callHook("prepare:scan.ts", scanned);
+  if (importItems["#silgi/vfs"].import.length === 0) {
+    delete importItems["#silgi/vfs"];
+  }
+  if (scanned.services.length > 0) {
+    importItems.silgi.import.push({ name: "mergeServices", key: "mergeServices" });
+  }
+  if (scanned.shareds.length > 0) {
+    importItems.silgi.import.push({ name: "mergeShared", key: "mergeShared" });
+  }
+  if (scanned.schemas.length > 0) {
+    importItems.silgi.import.push({ name: "mergeSchemas", key: "mergeSchemas" });
+  }
+  for (const key in importItems) {
+    importItems[key].import = deduplicateImportsByKey(importItems[key].import);
+  }
+  const importsContent = [
+    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
+      if (silgi.options.typescript.removeFileExtension) {
+        from = from.replace(/\.(js|ts|mjs|cjs|jsx|tsx)$/, "");
+      }
+      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${from}'`;
+    }),
+    "",
+    ...scanned.customImports,
+    ""
+  ];
+  const importData = [
+    `export const uris = ${JSON.stringify(scanned.uris, null, 2)}`,
+    "",
+    `export const modulesURIs = ${JSON.stringify(scanned.modulesURIs, null, 2)}`,
+    "",
+    scanned.schemas.length > 0 ? "export const schemas = mergeSchemas([" : "export const schemas = {",
+    ...scanned.schemas.map((name) => {
+      return `  ${name},`;
+    }),
+    scanned.schemas.length > 0 ? "])" : "}",
+    "",
+    scanned.services.length > 0 ? "export const services = mergeServices([" : "export const services = {",
+    ...scanned.services.map((name) => {
+      return `  ${name},`;
+    }),
+    scanned.services.length > 0 ? "])" : "}",
+    "",
+    scanned.shareds.length > 0 ? "export const shareds = mergeShared([" : "export const shareds = {",
+    ...scanned.shareds.map((name) => {
+      return `  ${name},`;
+    }),
+    scanned.shareds.length > 0 ? "])" : "}",
+    ""
+  ];
+  await silgi.callHook("after:prepare:scan.ts", importData);
+  importData.unshift(...importsContent);
+  return importData;
+}
+function deduplicateImportsByKey(imports) {
+  const seenKeys = /* @__PURE__ */ new Map();
+  return imports.filter((item) => {
+    if (seenKeys.has(item.key)) {
+      return false;
+    }
+    seenKeys.set(item.key, true);
+    return true;
+  });
+}
+
+export { prepareServerFiles };

package/dist/cli/scan/scanExportFile.mjs

@@ -0,0 +1,155 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { consola } from 'consola';
+import { globby } from 'globby';
+import { dirname, basename, relative, join, resolve, extname } from 'pathe';
+import { hasError, hash, relativeWithDot } from 'silgi/kit';
+import { withTrailingSlash } from 'ufo';
+import { isIgnored } from '../utils/ignore.mjs';
+import { SchemaParser } from '../utils/parser.mjs';
+
+async function scanExportFile(silgi) {
+  const filePaths = /* @__PURE__ */ new Set();
+  const scannedPaths = [];
+  const dir = silgi.options.serverDir;
+  const files = (await globby(dir, { cwd: silgi.options.rootDir, ignore: silgi.options.ignore })).sort();
+  if (files.length) {
+    const siblings = await readdir(dirname(dir)).catch(() => []);
+    const directory = basename(dir);
+    if (!siblings.includes(directory)) {
+      const directoryLowerCase = directory.toLowerCase();
+      const caseCorrected = siblings.find((sibling) => sibling.toLowerCase() === directoryLowerCase);
+      if (caseCorrected) {
+        const original = relative(silgi.options.serverDir, dir);
+        const corrected = relative(silgi.options.serverDir, join(dirname(dir), caseCorrected));
+        consola.warn(`Components not scanned from \`~/${corrected}\`. Did you mean to name the directory \`~/${original}\` instead?`);
+      }
+    }
+  }
+  for (const _file of files) {
+    const filePath = resolve(dir, _file);
+    if (scannedPaths.find((d) => filePath.startsWith(withTrailingSlash(d))) || isIgnored(filePath, silgi)) {
+      continue;
+    }
+    if (filePaths.has(filePath)) {
+      continue;
+    }
+    filePaths.add(filePath);
+    if (silgi.options.extensions.includes(extname(filePath))) {
+      const parser = new SchemaParser({
+        debug: false
+      });
+      const readfile = await readFile(filePath, "utf-8");
+      const { exportVariables, parseInterfaceDeclarations } = parser.parseExports(readfile, filePath);
+      const createServices = exportVariables("createService", filePath);
+      if (hasError("Parser", silgi)) {
+        return;
+      }
+      const scanTS = [];
+      const schemaTS = [];
+      if (createServices.length > 0) {
+        scanTS.push(...createServices.map(({ exportName, path }) => {
+          const randomString = hash(basename(path) + exportName);
+          const _name = `_v${randomString}`;
+          return { exportName, path, _name, type: "service" };
+        }));
+      }
+      const createSchemas = exportVariables("createSchema", filePath);
+      if (hasError("Parser", silgi)) {
+        return;
+      }
+      if (createSchemas.length > 0) {
+        scanTS.push(...createSchemas.map(({ exportName, path }) => {
+          const randomString = hash(basename(path) + exportName);
+          const _name = `_v${randomString}`;
+          return { exportName, path, _name, type: "schema" };
+        }));
+      }
+      const createShareds = exportVariables("createShared", filePath);
+      if (hasError("Parser", silgi)) {
+        return;
+      }
+      if (createShareds.length > 0) {
+        scanTS.push(...createShareds.map(({ exportName, path }) => {
+          const randomString = hash(basename(path) + exportName);
+          const _name = `_v${randomString}`;
+          return { exportName, path, _name, type: "shared" };
+        }));
+      }
+      const sharedsTypes = parseInterfaceDeclarations("ExtendShared", filePath);
+      if (hasError("Parser", silgi)) {
+        return;
+      }
+      if (sharedsTypes.length > 0) {
+        schemaTS.push(...sharedsTypes.map(({ exportName, path }) => {
+          const randomString = hash(basename(path) + exportName);
+          const _name = `_v${randomString}`;
+          return { exportName, path, _name, type: "shared" };
+        }));
+      }
+      const contextTypes = parseInterfaceDeclarations("ExtendContext", filePath);
+      if (hasError("Parser", silgi)) {
+        return;
+      }
+      if (contextTypes.length > 0) {
+        schemaTS.push(...contextTypes.map(({ exportName, path }) => {
+          const randomString = hash(basename(path) + exportName);
+          const _name = `_v${randomString}`;
+          return { exportName, path, _name, type: "context" };
+        }));
+      }
+      silgi.hook("prepare:scan.ts", (options) => {
+        for (const { exportName, path, _name, type } of scanTS) {
+          if (!path.includes("vfs")) {
+            silgi.options.devServer.watch.push(path);
+          }
+          if (type === "service") {
+            options.services.push(_name);
+          }
+          if (type === "shared") {
+            options.shareds.push(_name);
+          }
+          if (type === "schema") {
+            options.schemas.push(_name);
+          }
+          options.importItems[path] ??= {
+            import: [],
+            from: relativeWithDot(silgi.options.silgi.serverDir, path)
+          };
+          options.importItems[path].import.push({
+            name: `${exportName} as ${_name}`,
+            key: _name
+          });
+        }
+      });
+      silgi.hook("prepare:schema.ts", (options) => {
+        for (const { exportName, path, _name, type } of schemaTS) {
+          if (!path.includes("vfs")) {
+            silgi.options.devServer.watch.push(path);
+          }
+          if (type === "shared") {
+            options.shareds.push({
+              key: _name,
+              value: _name
+            });
+          }
+          if (type === "context") {
+            options.contexts.push({
+              key: _name,
+              value: _name
+            });
+          }
+          options.importItems[path] ??= {
+            import: [],
+            from: relativeWithDot(silgi.options.build.typesDir, path)
+          };
+          options.importItems[path].import.push({
+            name: `${exportName} as ${_name}`,
+            key: _name
+          });
+        }
+      });
+    }
+  }
+}
+
+export { scanExportFile };

package/dist/cli/scan/writeCoreFile.mjs

@@ -0,0 +1,34 @@
+import { resolve, join } from 'pathe';
+import { writeFile } from 'silgi/kit';
+import { prepareConfigs } from './prepareConfigs.mjs';
+import { prepareCoreFile } from './prepareCoreFile.mjs';
+import { prepareFramework } from './prepareFramework.mjs';
+
+async function writeCoreFile(silgi) {
+  const data = await prepareFramework(silgi);
+  const coreContent = await prepareCoreFile({
+    _importItems: data?.importItems ?? {},
+    _customImports: data?.customImports ?? []
+  }, data?.content ?? [], silgi);
+  const configs = await prepareConfigs(silgi);
+  const silgiDir = resolve(silgi.options.silgi.serverDir);
+  const buildFiles = [];
+  buildFiles.push({
+    path: join(silgiDir, "core.ts"),
+    contents: coreContent.join("\n")
+  });
+  buildFiles.push({
+    path: join(silgiDir, "configs.ts"),
+    contents: configs.join("\n")
+  });
+  for await (const file of buildFiles) {
+    if (!silgi.errors.length) {
+      await writeFile(
+        resolve(silgi.options.build.dir, file.path),
+        file.contents
+      );
+    }
+  }
+}
+
+export { writeCoreFile };

package/dist/cli/scan/writeScanFiles.mjs

@@ -0,0 +1,30 @@
+import { resolve } from 'pathe';
+import { writeFile, parseServices } from 'silgi/kit';
+import { buildUriMap } from '../utils/build-uri-map.mjs';
+import { readScanFile } from '../utils/readScanFile.mjs';
+import { prepareServerFiles } from './prepareServerFiles.mjs';
+
+async function writeScanFiles(silgi) {
+  const data = await prepareServerFiles(silgi);
+  if (!silgi.errors.length) {
+    await writeFile(
+      resolve(silgi.options.silgi.serverDir, "scan.ts"),
+      data.join("\n")
+    );
+  }
+  await readScanFile(silgi);
+  buildUriMap(silgi);
+  parseServices(silgi);
+  silgi.hook("prepare:scan.ts", (file) => {
+    file.uris = {
+      ...file.uris,
+      ...silgi.uris
+    };
+    file.modulesURIs = {
+      ...file.modulesURIs,
+      ...silgi.modulesURIs
+    };
+  });
+}
+
+export { writeScanFiles };

package/dist/cli/scan/writeTypesAndFiles.mjs

@@ -0,0 +1,109 @@
+import { existsSync } from 'node:fs';
+import { resolvePath, parseNodeModulePath, lookupNodeModuleSubpath } from 'mlly';
+import { resolve, relative, isAbsolute, join } from 'pathe';
+import { resolveAlias } from 'pathe/utils';
+import { isDirectory, writeFile } from 'silgi/kit';
+import { runtimeDir } from 'silgi/runtime/meta';
+import { toExports } from 'unimport';
+import { generateRouterDTS } from '../utils/generateRouterDTS.mjs';
+import { createDTSFramework } from './prepareFramework.mjs';
+import { prepareSchema } from './prepareSchema.mjs';
+import { silgiGenerateType } from '../config/types.mjs';
+
+async function writeTypesAndFiles(silgi) {
+  const routerDTS = await generateRouterDTS(silgi);
+  silgi.hook("prepare:types", (opts) => {
+    opts.references.push({ path: "./schema.d.ts" });
+    opts.references.push({ path: "./silgi-routes.d.ts" });
+    opts.references.push({ path: "./framework.d.ts" });
+  });
+  const schemaContent = await prepareSchema(silgi);
+  const frameworkDTS = await createDTSFramework(silgi);
+  const { declarations, tsConfig } = await silgiGenerateType(silgi);
+  const tsConfigPath = resolve(
+    silgi.options.rootDir,
+    silgi.options.typescript.tsconfigPath
+  );
+  const typesDir = resolve(silgi.options.build.typesDir);
+  let autoImportedTypes = [];
+  let autoImportExports = "";
+  if (silgi.unimport) {
+    await silgi.unimport.init();
+    const allImports = await silgi.unimport.getImports();
+    autoImportExports = toExports(allImports).replace(
+      /#internal\/nitro/g,
+      relative(typesDir, runtimeDir)
+    );
+    const resolvedImportPathMap = /* @__PURE__ */ new Map();
+    for (const i of allImports.filter((i2) => !i2.type)) {
+      if (resolvedImportPathMap.has(i.from)) {
+        continue;
+      }
+      let path = resolveAlias(i.from, silgi.options.alias);
+      if (isAbsolute(path)) {
+        const resolvedPath = await resolvePath(i.from, {
+          url: silgi.options.nodeModulesDirs
+        }).catch(() => null);
+        if (resolvedPath) {
+          const { dir, name } = parseNodeModulePath(resolvedPath);
+          if (!dir || !name) {
+            path = resolvedPath;
+          } else {
+            const subpath = await lookupNodeModuleSubpath(resolvedPath);
+            path = join(dir, name, subpath || "");
+          }
+        }
+      }
+      if (existsSync(path) && !await isDirectory(path)) {
+        path = path.replace(/\.[a-z]+$/, "");
+      }
+      if (isAbsolute(path)) {
+        path = relative(typesDir, path);
+      }
+      resolvedImportPathMap.set(i.from, path);
+    }
+    autoImportedTypes = [
+      silgi.options.imports && silgi.options.imports.autoImport !== false ? (await silgi.unimport.generateTypeDeclarations({
+        exportHelper: false,
+        resolvePath: (i) => resolvedImportPathMap.get(i.from) ?? i.from
+      })).trim() : ""
+    ];
+  }
+  const buildFiles = [];
+  buildFiles.push({
+    path: join(typesDir, "silgi-routes.d.ts"),
+    contents: routerDTS.join("\n")
+  });
+  buildFiles.push({
+    path: join(typesDir, "silgi-imports.d.ts"),
+    contents: [...autoImportedTypes, autoImportExports || "export {}"].join(
+      "\n"
+    )
+  });
+  buildFiles.push({
+    path: join(typesDir, "schema.d.ts"),
+    contents: schemaContent.join("\n")
+  });
+  buildFiles.push({
+    path: join(typesDir, "silgi.d.ts"),
+    contents: declarations.join("\n")
+  });
+  buildFiles.push({
+    path: tsConfigPath,
+    contents: JSON.stringify(tsConfig, null, 2)
+  });
+  buildFiles.push({
+    path: join(typesDir, "framework.d.ts"),
+    contents: frameworkDTS.content.join("\n")
+  });
+  for await (const file of buildFiles) {
+    if (!silgi.errors.length) {
+      await writeFile(
+        resolve(silgi.options.build.dir, file.path),
+        file.contents
+      );
+    }
+  }
+}
+
+export { writeTypesAndFiles };

package/dist/cli/utils/build-uri-map.mjs

@@ -0,0 +1,39 @@
+import { defu } from 'defu';
+
+function buildUriMap(silgi, currentPath = []) {
+  const uriMap = /* @__PURE__ */ new Map();
+  function traverse(node, path = []) {
+    if (!node || typeof node !== "object")
+      return;
+    if (path.length === 4) {
+      const basePath = path.join("/");
+      let pathString = "";
+      if (node.pathParams) {
+        let paths = null;
+        if (node.pathParams?._def?.typeName !== void 0) {
+          try {
+            const shape = node.pathParams?.shape;
+            paths = shape ? Object.keys(shape) : null;
+          } catch {
+            paths = null;
+          }
+        }
+        if (paths?.length) {
+          pathString = paths.map((p) => `:${p}`).join("/");
+        }
+      }
+      uriMap.set(basePath, pathString);
+      return;
+    }
+    for (const key in node) {
+      if (!["_type", "fields"].includes(key)) {
+        traverse(node[key], [...path, key]);
+      }
+    }
+  }
+  traverse(silgi.schemas, currentPath);
+  silgi.uris = defu(silgi.uris, Object.fromEntries(uriMap));
+  return uriMap;
+}
+
+export { buildUriMap };

package/dist/cli/utils/common.mjs

@@ -0,0 +1,13 @@
+const commonArgs = {
+  dir: {
+    type: "string",
+    description: "project root directory"
+  },
+  _dir: {
+    type: "positional",
+    default: ".",
+    description: "project root directory (prefer using `--dir`)"
+  }
+};
+
+export { commonArgs };

package/dist/cli/{compatibility.mjs → utils/compatibility.mjs}

@@ -27,4 +27,4 @@ function hasInstalledModule(moduleKey, silgi = useSilgiCLI()) {
   return find?.installed ?? false;
 }
 
-export { checkSilgiCompatibility as c, hasInstalledModule as h };
+export { checkSilgiCompatibility, hasInstalledModule, normalizeSemanticVersion };