silgi 0.33.1 → 0.34.0

package/dist/build.mjs

@@ -11,8 +11,6 @@ import 'hookable';
 import 'silgi/kit';
 import 'silgi/runtime/meta';
 import 'unimport';
-import './_chunks/routeRules.mjs';
-import 'ufo';
 import '@clack/prompts';
 import 'node:fs';
 import 'dotenv';
@@ -24,6 +22,7 @@ import 'silgi/meta';
 import 'node:url';
 import 'defu';
 import 'exsolve';
+import 'ufo';
 import 'node:fs/promises';
 import 'globby';
 import 'ignore';

package/dist/cli/build.mjs

@@ -2,10 +2,9 @@ import { consola } from 'consola';
 import { createHooks, createDebugger } from 'hookable';
 import { resolve, join, relative, extname, basename, dirname, isAbsolute } from 'pathe';
 import { useSilgiCLI, replaceRuntimeValues, silgiCLICtx, autoImportTypes } from 'silgi';
-import { isPresents, addTemplate, addCoreFile, relativeWithDot, hash, resolveAlias, directoryToURL, removeExtension, addImports, baseHeaderBannerComment, writeFile, parseServices, normalizeTemplate, useLogger, resolveSilgiPath, hasSilgiModule, genEnsureSafeVar, toArray, isDirectory } from 'silgi/kit';
+import { isPresents, addTemplate, addCoreFile, relativeWithDot, hash, resolveAlias, directoryToURL, removeExtension, addImports, baseHeaderBannerComment, writeFile, normalizeTemplate, useLogger, resolveSilgiPath, hasSilgiModule, genEnsureSafeVar, toArray, isDirectory } from 'silgi/kit';
 import { runtimeDir } from 'silgi/runtime/meta';
 import { scanExports, createUnimport, toExports } from 'unimport';
-import { c as createRouteRules } from '../_chunks/routeRules.mjs';
 import * as p from '@clack/prompts';
 import { existsSync, promises, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import * as dotenv from 'dotenv';
@@ -19,7 +18,7 @@ import { isRelative, withTrailingSlash } from 'ufo';
 import { readFile, readdir } from 'node:fs/promises';
 import { globby } from 'globby';
 import ignore from 'ignore';
-import { genImport, genTypeImport, genObjectFromRawEntries, genObjectFromRaw, genObjectFromValues, genAugmentation } from 'knitwork';
+import { genImport, genTypeImport, genAugmentation, genObjectFromRawEntries } from 'knitwork';
 import { klona } from 'klona';
 import { useSilgiRuntimeConfig, initRuntimeConfig } from 'silgi/runtime';
 import { createStorage, builtinDrivers } from 'unstorage';
@@ -416,32 +415,6 @@ async function registerModuleExportScan(silgi) {
         });
         options.methods.push({ key: configKey, value: importName });
       }
-      if (hasTypeExport("ModuleRuntimeRouteRules")) {
-        const importName = hash(`${configKey}ModuleRuntimeRouteRules`);
-        options.addImportItemType({
-          imports: [
-            {
-              as: importName,
-              name: "ModuleRuntimeRouteRules"
-            }
-          ],
-          specifier
-        });
-        options.routeRules.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeRouteRulesConfig")) {
-        const importName = hash(`${configKey}ModuleRuntimeRouteRulesConfig`);
-        options.addImportItemType({
-          imports: [
-            {
-              as: importName,
-              name: "ModuleRuntimeRouteRulesConfig"
-            }
-          ],
-          specifier
-        });
-        options.routeRulesConfig.push({ key: configKey, value: importName });
-      }
     }
   });
 }
@@ -791,7 +764,8 @@ function categorizeExports(exportedEntities, filePath) {
   const functionExportCategories = {
     createService: "service",
     createSchema: "schema",
-    createShared: "shared"
+    createShared: "shared",
+    createRoute: "route"
   };
   for (const [functionName, category] of Object.entries(functionExportCategories)) {
     const matchingExports = exportedEntities.filter((entity) => entity.funcName === functionName);
@@ -843,6 +817,9 @@ function registerExportsWithHooks(silgiInstance, runtimeExports, typeExports) {
         case "schema":
           options.schemas.push(uniqueId);
           break;
+        case "route":
+          options.routers.push(uniqueId);
+          break;
       }
       options.addImportItem({
         specifier: removeExtension(relativeWithDot(silgiInstance.options.silgi.serverDir, path)),
@@ -946,42 +923,6 @@ async function scanExportFile(silgiInstance) {
   }
 }
 
-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;
-}
-
 async function readScanFile(silgi) {
   const path = resolve(silgi.options.silgi.serverDir, "scan.ts");
   const context = await promises.readFile(path, { encoding: "utf-8" });
@@ -1013,19 +954,15 @@ ${injectedResult.code}`;
         return (await silgi.unimport.injectImports(data, name)).code;
       }
     );
-    silgi.uris = defu(silgi.uris, scanFile.uris) || {};
-    silgi.schemas = defu(scanFile.schemas, scanFile.uris) || {};
-    silgi.services = defu(scanFile.services, scanFile.uris) || {};
-    silgi.shareds = defu(scanFile.shareds, scanFile.shareds) || {};
-    silgi.modulesURIs = defu(scanFile.modulesURIs, scanFile.modulesURIs) || {};
+    silgi.schemas = scanFile.schemas || {};
+    silgi.services = scanFile.services || {};
+    silgi.shareds = scanFile.shareds || {};
     return {
       context,
       object: {
         schemas: scanFile.schemas,
-        uris: scanFile.uris,
         services: scanFile.services,
-        shareds: scanFile.shareds,
-        modulesURIs: scanFile.modulesURIs
+        shareds: scanFile.shareds
       },
       path
     };
@@ -1039,10 +976,8 @@ ${injectedResult.code}`;
       context,
       object: {
         schemas: {},
-        uris: {},
         services: {},
-        shareds: {},
-        modulesURIs: {}
+        shareds: {}
       },
       path
     };
@@ -1060,6 +995,9 @@ async function prepareScanFile(silgi) {
           },
           {
             name: "createShared"
+          },
+          {
+            name: "deepMergeObjects"
           }
         ]
       },
@@ -1087,50 +1025,14 @@ async function prepareScanFile(silgi) {
     ]
   });
   const scanned = {
-    uris: {},
     services: [],
     shareds: [],
+    routers: [],
     schemas: [],
-    modulesURIs: {},
     addImportItem,
     addImportItemType
   };
-  if (silgi.uris) {
-    defu(scanned.uris, silgi.uris);
-  }
-  if (silgi.modulesURIs) {
-    scanned.shareds.push(
-      `createShared({
-        modulesURIs,
-      })`
-    );
-    defu(scanned.modulesURIs, silgi.modulesURIs);
-  }
   await silgi.callHook("before:scan.ts", scanned);
-  if (scanned.services.length > 0) {
-    addImportItem({
-      specifier: "silgi",
-      imports: {
-        name: "mergeServices"
-      }
-    });
-  }
-  if (scanned.shareds.length > 0) {
-    addImportItem({
-      specifier: "silgi",
-      imports: {
-        name: "mergeShared"
-      }
-    });
-  }
-  if (scanned.schemas.length > 0) {
-    addImportItem({
-      specifier: "silgi",
-      imports: {
-        name: "mergeSchemas"
-      }
-    });
-  }
   const importsContent = [
     ...genImports.map(({ specifier, imports, options }) => {
       return genImport(specifier, imports, options);
@@ -1141,27 +1043,31 @@ async function prepareScanFile(silgi) {
     ""
   ];
   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.length > 0 ? "export const schemas = deepMergeObjects([" : "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.length > 0 ? "export const services = deepMergeObjects([" : "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.length > 0 ? "export const shareds = deepMergeObjects([" : "export const shareds = {",
     ...scanned.shareds.map((name) => {
       return `  ${name},`;
     }),
+    "",
     scanned.shareds.length > 0 ? "])" : "}",
+    "",
+    scanned.routers.length > 0 ? "export const routers = deepMergeObjects([" : "export const routers = {",
+    ...scanned.routers.map((name) => {
+      return `  ${name},`;
+    }),
+    scanned.routers.length > 0 ? "])" : "}",
     ""
   ];
   await silgi.callHook("after:scan.ts", importData);
@@ -1179,18 +1085,6 @@ async function writeScanFiles(silgi) {
     );
   }
   await readScanFile(silgi);
-  buildUriMap(silgi);
-  parseServices(silgi);
-  silgi.hook("before:scan.ts", (file) => {
-    file.uris = {
-      ...file.uris,
-      ...silgi.uris
-    };
-    file.modulesURIs = {
-      ...file.modulesURIs,
-      ...silgi.modulesURIs
-    };
-  });
 }
 
 async function createStorageCLI(silgi) {
@@ -1441,10 +1335,8 @@ async function createSilgiCLI(config = {}, opts = {}) {
   const options = await loadOptions(config, opts);
   const hooks = createHooks();
   const silgi = {
-    modulesURIs: {},
     scannedURIs: /* @__PURE__ */ new Map(),
     services: {},
-    uris: {},
     shareds: {},
     schemas: {},
     unimport: void 0,
@@ -1462,7 +1354,6 @@ async function createSilgiCLI(config = {}, opts = {}) {
     hook: hooks.hook,
     async updateConfig(_config) {
     },
-    routeRules: void 0,
     adapters: {}
   };
   if (silgi.options.adapters && Object.keys(silgi.options.adapters)?.length > 0) {
@@ -1471,9 +1362,6 @@ async function createSilgiCLI(config = {}, opts = {}) {
     }
   }
   await prepareEnv(options);
-  const routeRules = createRouteRules();
-  routeRules.importRules(options.routeRules ?? {});
-  silgi.routeRules = routeRules;
   if (silgiCLICtx.tryUse()) {
     silgiCLICtx.unset();
     silgiCLICtx.set(silgi);
@@ -1525,11 +1413,6 @@ async function createSilgiCLI(config = {}, opts = {}) {
       imports: autoImportTypes.map((type) => type),
       type: true
     });
-    silgi.options.imports.presets.push({
-      from: "silgi/types",
-      imports: autoImportTypes.map((type) => type),
-      type: true
-    });
     silgi.options.imports.presets.push({
       from: "silgi/runtime/internal/ofetch",
       imports: ["createSilgiFetch", "silgi$fetch"]
@@ -1583,44 +1466,6 @@ async function generateApiFul(silgi) {
 async function prepare(_silgi) {
 }
 
-async function exportRules(silgi) {
-  try {
-    if (!silgi?.routeRules?.exportRules) {
-      throw new Error("Invalid silgi configuration: routeRules or exportRules is undefined");
-    }
-    const exportedRules = silgi.routeRules.exportRules();
-    if (!exportedRules || typeof exportedRules !== "object") {
-      throw new Error("No valid route rules to export");
-    }
-    const content = `/* eslint-disable */
-// @ts-nocheck
-// This file is auto-generated at build time by Silgi
-// Contains route rules with preserved functions
-// DO NOT MODIFY THIS FILE DIRECTLY
-
-export const routeRules = ${genObjectFromRawEntries(
-      Object.entries(exportedRules).map(([key, value]) => {
-        if (typeof value === "function") {
-          return [key, genObjectFromRaw(value)];
-        }
-        return [key, genObjectFromValues(value)];
-      })
-    )}
-`;
-    const serverDir = silgi.options.silgi.serverDir;
-    if (!serverDir) {
-      throw new Error("Server directory not defined in configuration");
-    }
-    const file = join(serverDir, "rules.ts");
-    if (!silgi.errors.length) {
-      await writeFile(file, content);
-    }
-  } catch (error) {
-    console.error("\u274C Failed to prepare build:", error instanceof Error ? error.message : String(error));
-    throw error;
-  }
-}
-
 function debugMode(name) {
   const silgi = useSilgiCLI$1();
   if (silgi.options.debug === true || typeof silgi.options.debug === "object" && silgi.options.debug[name]) {
@@ -1736,9 +1581,6 @@ async function prepareCoreFile(silgi) {
       {
         specifier: "./scan",
         imports: [
-          {
-            name: "uris"
-          },
           {
             name: "services"
           },
@@ -1747,9 +1589,6 @@ async function prepareCoreFile(silgi) {
           },
           {
             name: "schemas"
-          },
-          {
-            name: "modulesURIs"
           }
         ]
       },
@@ -1840,8 +1679,6 @@ async function prepareCoreFile(silgi) {
     " shared: shareds,",
     " services: services,",
     " schemas: schemas,",
-    " uris,",
-    " modulesURIs,",
     ` plugins: [${plugins.join(", ")}],`,
     "",
     _data.silgiConfigs.length > 0 ? _data.silgiConfigs.map((item) => {
@@ -1894,100 +1731,9 @@ async function writeCoreFile(silgi) {
   }
 }
 
-async function generateRouterDTS(silgi) {
-  const uris = silgi.uris;
-  const subPath = "srn";
-  const groupedPaths = /* @__PURE__ */ new Map();
-  Object.entries(uris || {}).forEach(([key, params]) => {
-    const [service, resource, method, action] = key.split("/");
-    const basePath = params ? `${subPath}/${service}/${resource}/${action}/${params}` : `${subPath}/${service}/${resource}/${action}`;
-    const fullPath = `${subPath}/${service}/${resource}/${action}`;
-    if (!groupedPaths.has(basePath)) {
-      groupedPaths.set(basePath, /* @__PURE__ */ new Map());
-    }
-    groupedPaths.get(basePath)?.set(method.toLowerCase(), fullPath);
-  });
-  const keys = [
-    "  keys: {",
-    Array.from(groupedPaths.entries()).map(([basePath, methods]) => {
-      return `    '/${basePath}': {${Array.from(methods.entries()).map(([method, path]) => `
-      ${method}: '/${path}'`).join(",")}
-    }`;
-    }).join(",\n"),
-    "  }",
-    ""
-  ].join("\n");
-  const groupedRoutes = Object.entries(uris || {}).reduce((acc, [key, _params]) => {
-    const [service, resource, method, action] = key.split("/");
-    const routePath = `${subPath}/${service}/${resource}/${action}`;
-    if (!acc[routePath]) {
-      acc[routePath] = {};
-    }
-    acc[routePath][method] = {
-      input: `ExtractInputFromURI<'${key}'>`,
-      output: `ExtractOutputFromURI<'${key}'>`,
-      queryParams: `ExtractQueryParamsFromURI<'${key}'>`,
-      pathParams: `ExtractPathParamsFromURI<'${key}'>`
-    };
-    return acc;
-  }, {});
-  const routerTypes = Object.entries(groupedRoutes).map(([path, methods]) => {
-    const methodEntries = Object.entries(methods).map(([method, { input, output, queryParams, pathParams }]) => {
-      return `    '${method}': {
-      input: ${input},
-      output: ${output},
-      queryParams: ${queryParams},
-      pathParams: ${pathParams}
-    }`;
-    }).join(",\n");
-    return `  '/${path}': {
-${methodEntries}
-  }`;
-  });
-  const nitro = [
-    "declare module 'nitropack/types' {",
-    "  interface InternalApi extends RouterTypes {}",
-    "}"
-  ];
-  const content = [
-    keys.slice(0, -1),
-    // son satırdaki boş satırı kaldır
-    ...routerTypes
-  ].join(",\n");
-  const context = [
-    "import type { ExtractInputFromURI, ExtractOutputFromURI, ExtractQueryParamsFromURI, ExtractPathParamsFromURI } from 'silgi/types'",
-    "",
-    "export interface RouterTypes {",
-    content,
-    "}",
-    "",
-    "declare module 'silgi/types' {",
-    "  interface SilgiRouterTypes extends RouterTypes {",
-    "  }",
-    "}",
-    "",
-    silgi.options.preset === "h3" || silgi.options.preset === "nitro" ? nitro.join("\n") : "",
-    "",
-    "export {}"
-  ];
-  return context;
-}
-
 async function prepareSchema(silgi) {
   const { genImports, genTypeImports, addImportItem, addImportItemType } = addImports({
-    imports: [
-      {
-        specifier: relativeWithDot(
-          silgi.options.build.typesDir,
-          `${silgi.options.silgi.serverDir}/scan`
-        ),
-        imports: [
-          {
-            name: "modulesURIs"
-          }
-        ]
-      }
-    ],
+    imports: [],
     typeImports: [
       {
         specifier: "silgi/types",
@@ -1995,9 +1741,6 @@ async function prepareSchema(silgi) {
           {
             name: "URIsTypes"
           },
-          {
-            name: "Namespaces"
-          },
           {
             name: "SilgiRuntimeContext"
           }
@@ -2011,19 +1754,12 @@ async function prepareSchema(silgi) {
     options: [],
     contexts: [],
     actions: [],
-    shareds: [
-      {
-        key: "modulesURIs",
-        value: "{ modulesURIs: typeof modulesURIs }"
-      }
-    ],
+    shareds: [],
     events: [],
     hooks: [],
     runtimeHooks: [],
     runtimeOptions: [],
-    methods: [],
-    routeRules: [],
-    routeRulesConfig: []
+    methods: []
   };
   await silgi.callHook("before:schema.ts", data);
   const silgiScanTS = relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/scan`);
@@ -2053,9 +1789,9 @@ async function prepareSchema(silgi) {
       }
     ),
     "",
-    `type SchemaExtends = Namespaces<typeof import('${silgiScanTS}')['schemas']>`,
-    "",
-    `type SilgiURIsMerge = URIsTypes<typeof import('${silgiScanTS}')['uris']>`,
+    `type SchemaExtends = typeof import('${silgiScanTS}')['schemas']`,
+    `type BaseServices = typeof import('${silgiScanTS}')['services']`,
+    `type RoutersExtend = typeof import('${silgiScanTS}')['routers']`,
     "",
     `type SilgiModuleContextExtends = ${data.contexts.length ? data.contexts.map(({ value }) => value).join(" & ") : "{}"}`,
     "",
@@ -2072,10 +1808,6 @@ async function prepareSchema(silgi) {
     "",
     `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(" & ") : "{}"}`,
@@ -2127,11 +1859,12 @@ async function prepareSchema(silgi) {
     genAugmentation("silgi/types", {
       FrameworkContext: [{}, { extends: ["FrameworkContextExtends"] }],
       SilgiSchema: [{}, { extends: ["SchemaExtends"] }],
+      ServicesObject: [{}, { extends: ["BaseServices"] }],
       SilgiNamespaces: [{}, { extends: ["InferredNamespaces"] }],
       SilgiStorageBase: [{}, { extends: ["SilgiStorageBaseExtends"] }],
       SilgiURIs: [{}, { extends: ["SilgiURIsMerge"] }],
       SilgiRuntimeContext: [{}, { extends: ["SilgiModuleContextExtends"] }],
-      SilgiEvents: [{}, { extends: ["SilgiModuleEventsExtends"] }],
+      SilgiEvent: [{}, { extends: ["SilgiModuleEventsExtends"] }],
       SilgiRuntimeSharedsExtend: [{}, { extends: ["SilgiModuleSharedExtends"] }],
       SilgiRuntimeActions: [{}, { extends: ["RuntimeActionExtends"] }],
       SilgiRuntimeOptions: [{}, { extends: ["SilgiRuntimeOptionExtends"] }],
@@ -2139,8 +1872,7 @@ async function prepareSchema(silgi) {
       SilgiRuntimeConfig: [{}, { extends: ["SilgiRuntimeConfigExtends"] }],
       SilgiHooks: [{}, { extends: ["ModuleHooksExtend"] }],
       SilgiRuntimeMethods: [{}, { extends: ["RuntimeMethodExtends"] }],
-      SilgiRuntimeRouteRules: [{}, { extends: ["RuntimeRouteRulesExtends"] }],
-      SilgiRuntimeRouteRulesConfig: [{}, { extends: ["RuntimeRouteRulesConfigExtends"] }],
+      Routers: [{}, { extends: ["RoutersExtend"] }],
       SilgiModuleOptions: [{}, { extends: ["SilgiModuleOptionExtend"] }]
     }).replace(/,\s*/g, "\n"),
     "",
@@ -2152,7 +1884,6 @@ async function prepareSchema(silgi) {
 }
 
 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" });
@@ -2209,10 +1940,6 @@ async function writeTypesAndFiles(silgi) {
     ];
   }
   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(
@@ -2246,7 +1973,6 @@ async function build(silgi) {
   await generateApiFul(silgi);
   await prepareCommands(silgi);
   await writeCoreFile(silgi);
-  await exportRules(silgi);
   await writeTypesAndFiles(silgi);
   await generateApp(silgi);
 }

package/dist/cli/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
 
-const version = "0.33.1";
+const version = "0.34.0";
 const packageJson = {
 	version: version};
 

package/dist/cli/init.mjs

@@ -12,8 +12,6 @@ import 'silgi';
 import 'silgi/kit';
 import 'silgi/runtime/meta';
 import 'unimport';
-import '../_chunks/routeRules.mjs';
-import 'ufo';
 import 'dotenv';
 import 'mlly';
 import 'dev-jiti';
@@ -22,6 +20,7 @@ import 'semver/functions/satisfies.js';
 import 'node:url';
 import 'defu';
 import 'exsolve';
+import 'ufo';
 import 'globby';
 import 'ignore';
 import 'knitwork';

package/dist/cli/install.mjs

@@ -12,8 +12,6 @@ import 'hookable';
 import 'silgi';
 import 'silgi/runtime/meta';
 import 'unimport';
-import '../_chunks/routeRules.mjs';
-import 'ufo';
 import '@clack/prompts';
 import 'node:fs';
 import 'dotenv';
@@ -24,6 +22,7 @@ import 'semver/functions/satisfies.js';
 import 'node:url';
 import 'defu';
 import 'exsolve';
+import 'ufo';
 import 'node:fs/promises';
 import 'globby';
 import 'ignore';
@@ -45,6 +44,18 @@ import 'pathe/utils';
 import 'untyped';
 
 async function installPackages(silgi = useSilgiCLI()) {
+  await addNPMPackage([
+    {
+      name: "zod-to-json-schema",
+      isDev: false,
+      when: silgi.options.schemaVendor === "zod"
+    },
+    {
+      name: "@valibot/to-json-schema",
+      isDev: false,
+      when: silgi.options.schemaVendor === "valibot"
+    }
+  ]);
   await addNPMPackage([
     {
       name: "@fastify/deepmerge",