silgi 0.29.7 → 0.29.9

package/dist/cli/dev.mjs

@@ -45,6 +45,7 @@ import 'klona';
 import 'silgi/runtime';
 import 'unstorage';
 import 'scule';
+import 'node:child_process';
 
 async function reloadScan(path, _stats) {
   const silgi = useSilgiCLI();

package/dist/cli/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
 
-const version = "0.29.7";
+const version = "0.29.9";
 const packageJson = {
 	version: version};
 
@@ -20,7 +20,7 @@ const main = defineCommand({
   subCommands: {
     prepare: () => import('./prepare.mjs').then(function (n) { return n.a; }).then((m) => m.default),
     init: () => import('./init.mjs').then((m) => m.default),
-    run: () => import('./run.mjs').then((m) => m.default),
+    run: () => import('./prepare.mjs').then(function (n) { return n.r; }).then((m) => m.default),
     install: () => import('./install.mjs').then((m) => m.default),
     dev: () => import('./dev.mjs').then((m) => m.default)
   },

package/dist/cli/init.mjs

@@ -41,6 +41,9 @@ import 'klona';
 import 'silgi/runtime';
 import 'unstorage';
 import 'scule';
+import 'node:child_process';
+import '../_chunks/silgiApp.mjs';
+import 'unctx';
 
 const init = defineCommand({
   meta: {

package/dist/cli/prepare.mjs

@@ -1,7 +1,17 @@
-import { defineCommand } from 'citty';
+import { defineCommand, runCommand } from 'citty';
 import { resolve } from 'pathe';
 import { version } from 'silgi/meta';
-import { c as createSilgiCLI, b as build } from './silgi.mjs';
+import { p as prepareEnv, c as createSilgiCLI, b as build } from './silgi.mjs';
+import { execSync } from 'node:child_process';
+import * as p from '@clack/prompts';
+import { isCancel, cancel } from '@clack/prompts';
+import { consola } from 'consola';
+import { createJiti } from 'dev-jiti';
+import { useSilgiCLI as useSilgiCLI$1 } from 'silgi';
+import { u as useSilgiCLI, a as silgiCLIIClose } from '../_chunks/silgiApp.mjs';
+import { addTemplate } from 'silgi/kit';
+import { generateTypes, resolveSchema } from 'untyped';
+import { l as loadOptions } from './types.mjs';
 
 const commonArgs = {
   dir: {
@@ -15,6 +25,175 @@ const commonArgs = {
   }
 };
 
+function debugMode(name) {
+  const silgi = useSilgiCLI();
+  if (silgi.options.debug === true || typeof silgi.options.debug === "object" && silgi.options.debug[name]) {
+    return true;
+  }
+  return false;
+}
+
+async function scanCommands(silgi = useSilgiCLI()) {
+  const commands = [];
+  await silgi.callHook("prepare:commands", commands);
+  if (debugMode("command")) {
+    addTemplate({
+      filename: "cli.json",
+      where: ".silgi",
+      write: true,
+      getContents: () => JSON.stringify(commands, null, 2)
+    });
+  }
+  silgi.hook("prepare:schema.ts", async (object) => {
+    const allTags = commands.reduce((acc, commandGroup) => {
+      Object.values(commandGroup).forEach((command) => {
+        if (command.tags) {
+          command.tags.forEach((tag) => acc.add(tag));
+        }
+      });
+      return acc;
+    }, /* @__PURE__ */ new Set());
+    const data = [
+      "",
+      generateTypes(
+        await resolveSchema(
+          {
+            ...Object.fromEntries(Array.from(allTags.values()).map((tag) => [tag, "string"]))
+          }
+        ),
+        {
+          interfaceName: "SilgiCommandsExtended",
+          addExport: false,
+          addDefaults: false,
+          allowExtraKeys: false,
+          indentation: 0
+        }
+      ),
+      ""
+    ];
+    object.customImports?.push(...data);
+  });
+  return commands;
+}
+
+function cancelOnCancel({
+  value,
+  message = "Cancelled",
+  onBeforeExit,
+  exitCode = 0
+} = {}) {
+  const handleCancel = () => {
+    cancel(message);
+    onBeforeExit?.();
+    process.exit(exitCode);
+  };
+  if (!value || isCancel(value))
+    handleCancel();
+}
+
+const run = defineCommand({
+  meta: {
+    name: "run",
+    description: "Run a command from the CLI",
+    version: version
+  },
+  args: {
+    ...commonArgs,
+    preset: {
+      type: "string",
+      description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
+    },
+    tag: {
+      type: "string"
+    },
+    prepare: {
+      type: "boolean",
+      description: "Run in silgi development mode",
+      default: true
+    }
+  },
+  async run({ args }) {
+    if (args.prepare) {
+      await runCommand(prepare, {
+        rawArgs: ["--commandType", "run"]
+      });
+    }
+    const silgi = useSilgiCLI$1();
+    if (!silgi) {
+      throw new Error("Silgi is not initialized");
+    }
+    const commands = await scanCommands();
+    globalThis.__nitro__ = globalThis.__nitro__ || {};
+    globalThis.__nitro__.useRuntimeConfig = function() {
+      return silgi?.options?.runtimeConfig || {};
+    };
+    const tags = args.tag?.split(",").map((t) => t.trim());
+    const silgiConfig = await loadOptions({});
+    await prepareEnv(silgiConfig);
+    let selectedCommands = [];
+    if (tags?.length) {
+      selectedCommands = commands.filter((cmd) => cmd.tags?.some((tag) => tags.includes(tag))).filter((cmd) => cmd.when !== false);
+    } else {
+      selectedCommands = commands.filter((cmd) => cmd.when !== false);
+    }
+    if (!selectedCommands.length) {
+      return;
+    }
+    const multiSelect = await p.groupMultiselect({
+      message: "Select commands to run",
+      required: true,
+      options: {
+        ...selectedCommands.sort((a, b) => (a.order || Infinity) - (b.order || Infinity)).reduce((acc, cmd) => {
+          if (!acc[cmd.group || ""]) {
+            acc[cmd.group || ""] = [];
+          }
+          acc[cmd.group || ""].push({
+            label: cmd.name,
+            value: cmd,
+            hint: cmd.description
+          });
+          return acc;
+        }, {})
+      }
+    });
+    cancelOnCancel({ value: multiSelect });
+    selectedCommands = multiSelect;
+    const spinner = p.spinner({
+      indicator: "dots"
+    });
+    for (const cmd of selectedCommands) {
+      const data = cmd.getContents({ app: silgi });
+      spinner.start(`[${cmd.group}] ${cmd.name}...`);
+      if (cmd.type === "command") {
+        execSync(data, { stdio: "inherit" });
+      }
+      if (cmd.type === "function") {
+        const jiti = createJiti(import.meta.url, {
+          alias: silgiConfig.alias
+        });
+        let cleanHandler = cmd.getContents({ app: silgi }).replace(/\n/g, "");
+        cleanHandler = `import { silgiCLICtx } from 'silgi' 
+        ${cleanHandler}
+`;
+        await jiti.evalModule(cleanHandler, {
+          filename: import.meta.url,
+          async: true,
+          conditions: silgiConfig.conditions,
+          forceTranspile: true
+        });
+      }
+      spinner.stop();
+      consola.success(`[${cmd.group}] ${cmd.name} done`);
+    }
+    await silgiCLIIClose();
+  }
+});
+
+const run$1 = {
+  __proto__: null,
+  default: run
+};
+
 const prepare = defineCommand({
   meta: {
     name: "prepare",
@@ -55,6 +234,11 @@ const prepare = defineCommand({
       activeEnvironment: args.env
     });
     await build(silgi);
+    if (args.commandType !== "run") {
+      await runCommand(run, {
+        rawArgs: ["--tag", "init", "--prepare", "false"]
+      });
+    }
   }
 });
 
@@ -63,4 +247,4 @@ const prepare$1 = {
   default: prepare
 };
 
-export { prepare$1 as a, commonArgs as c, prepare as p };
+export { prepare$1 as a, commonArgs as c, prepare as p, run$1 as r };

package/dist/cli/silgi.mjs

@@ -1,10 +1,10 @@
 import { generateDTS } from 'apiful/openapi';
 import consola$1, { consola } from 'consola';
 import { join, resolve, dirname, isAbsolute, relative, basename, extname } from 'pathe';
-import { hasSilgiModule, addTemplate, normalizeTemplate, useLogger, genEnsureSafeVar, hash, relativeWithDot, writeFile, isDirectory, resolveAlias as resolveAlias$1, directoryToURL, hasError, parseServices, resolveSilgiPath } from 'silgi/kit';
+import { hasSilgiModule, addTemplate, normalizeTemplate, useLogger, genEnsureSafeVar, toArray, hash, writeFile, relativeWithDot, isDirectory, resolveAlias as resolveAlias$1, directoryToURL, hasError, parseServices, resolveSilgiPath } from 'silgi/kit';
 import { mkdirSync, existsSync, writeFileSync, promises, readFileSync } from 'node:fs';
 import { readdir, readFile } from 'node:fs/promises';
-import { genObjectFromRawEntries, genObjectFromRaw, genObjectFromValues } from 'knitwork';
+import { genObjectFromRawEntries, genImport, genTypeImport, genObjectFromRaw, genObjectFromValues } from 'knitwork';
 import { resolvePath, parseNodeModulePath, lookupNodeModuleSubpath, resolveModuleExportNames, findTypeExports, findExports } from 'mlly';
 import { resolveAlias } from 'pathe/utils';
 import { runtimeDir } from 'silgi/runtime/meta';
@@ -233,237 +233,209 @@ async function prepareConfigs(silgi) {
   return importData;
 }
 
-async function prepareCoreFile(data, frameworkContext, silgi) {
-  let importItems = {
-    "silgi": {
-      import: [
-        {
-          name: "createSilgi",
-          key: "createSilgi"
-        }
-      ],
-      from: "silgi"
-    },
-    "silgi/types": {
-      import: [
-        {
-          name: "SilgiRuntimeOptions",
-          type: true,
-          key: "SilgiRuntimeOptions"
-        },
-        {
-          name: "FrameworkContext",
-          type: true,
-          key: "FrameworkContext"
-        },
-        {
-          name: "SilgiOptions",
-          type: true,
-          key: "SilgiOptions"
-        }
-      ],
-      from: "silgi/types"
-    },
-    "#silgi/vfs": {
-      import: [],
-      from: "./vfs"
-    },
-    "scan.ts": {
-      import: [
-        {
-          name: "uris",
-          type: false,
-          key: "uris"
-        },
-        {
-          name: "services",
-          type: false,
-          key: "services"
-        },
-        {
-          name: "shareds",
-          type: false,
-          key: "shareds"
-        },
-        {
-          name: "schemas",
-          type: false,
-          key: "schemas"
-        },
-        {
-          name: "modulesURIs",
-          type: false,
-          key: "modulesURIs"
-        }
-      ],
-      from: "./scan.ts"
-    },
-    "configs.ts": {
-      import: [
-        {
-          name: "cliConfigs",
-          type: false,
-          key: "cliConfigs"
+function scanImports(data) {
+  const genImports = [
+    ...data.imports ?? []
+  ];
+  const genTypeImports = [
+    ...data.typeImports ?? []
+  ];
+  function addImportItem(data2) {
+    for (const item of toArray(data2)) {
+      const isSpecifier = genImports.some((i) => i.specifier === item.specifier);
+      if (isSpecifier) {
+        const index = genImports.findIndex((i) => i.specifier === item.specifier);
+        if (Array.isArray(genImports[index].imports)) {
+          genImports[index].imports ??= [];
+          genImports[index].imports.push(...toArray(item.imports));
+        } else {
+          genImports[index].imports = item.imports;
         }
-      ],
-      from: "./configs.ts"
-    },
-    "rules.ts": {
-      import: [
-        {
-          name: "routeRules",
-          key: "routeRules"
+      } else {
+        genImports.push({
+          specifier: item.specifier,
+          imports: item.imports,
+          options: item.options
+        });
+      }
+    }
+  }
+  function addImportItemType(data2) {
+    for (const item of toArray(data2)) {
+      const isSpecifier = genTypeImports.some((i) => i.specifier === item.specifier);
+      if (isSpecifier) {
+        const index = genTypeImports.findIndex((i) => i.specifier === item.specifier);
+        if (Array.isArray(genTypeImports[index].imports)) {
+          genTypeImports[index].imports ??= [];
+          genTypeImports[index].imports.push(...toArray(item.imports));
+        } else {
+          genTypeImports[index].imports = item.imports;
         }
-      ],
-      from: "./rules.ts"
+      } else {
+        genTypeImports.push({
+          specifier: item.specifier,
+          imports: item.imports,
+          options: item.options
+        });
+      }
     }
+  }
+  return {
+    genImports,
+    genTypeImports,
+    addImportItem,
+    addImportItemType
   };
-  importItems = { ...data._importItems, ...importItems };
+}
+
+async function prepareCoreFile(silgi) {
+  const { genImports, genTypeImports, addImportItem, addImportItemType } = scanImports({
+    imports: [
+      {
+        specifier: "silgi/runtime",
+        imports: [
+          {
+            name: "mergeDeep"
+          }
+        ]
+      },
+      {
+        specifier: "silgi",
+        imports: [
+          {
+            name: "createSilgi"
+          }
+        ]
+      },
+      {
+        specifier: "./scan",
+        imports: [
+          {
+            name: "uris"
+          },
+          {
+            name: "services"
+          },
+          {
+            name: "shareds"
+          },
+          {
+            name: "schemas"
+          },
+          {
+            name: "modulesURIs"
+          }
+        ]
+      },
+      {
+        specifier: "./configs",
+        imports: [
+          {
+            name: "cliConfigs"
+          }
+        ]
+      },
+      {
+        specifier: "./rules",
+        imports: [
+          {
+            name: "routeRules"
+          }
+        ]
+      }
+    ],
+    typeImports: [
+      {
+        specifier: "silgi/types",
+        imports: [
+          {
+            name: "SilgiRuntimeOptions"
+          },
+          {
+            name: "BuildSilgi"
+          }
+        ]
+      }
+    ]
+  });
+  const before = [];
+  const after = [];
   const _data = {
-    customImports: data._customImports || [],
-    buildSilgiExtraContent: [],
-    beforeBuildSilgiExtraContent: [],
-    afterCliOptions: [],
-    _silgiConfigs: [],
-    customContent: [],
-    importItems
+    silgiConfigs: [],
+    addImportItem,
+    addImportItemType,
+    addFunction: (data) => {
+      for (const item of data) {
+        if (item.where === "after") {
+          after.push(item.params?.length ? ` await ${item.name}(option, ${item.params.join(",")})` : ` await ${item.name}(framework)`);
+        }
+        if (item.where === "before") {
+          before.push(item.params?.length ? ` await ${item.name}(option, ${item.params.join(",")})` : ` await ${item.name}(framework)`);
+        }
+      }
+    }
   };
-  await silgi.callHook("prepare:core.ts", _data);
-  if (importItems["#silgi/vfs"].import.length === 0) {
-    delete importItems["#silgi/vfs"];
-  }
+  await silgi.callHook("before:core.ts", _data);
   const plugins = [];
   for (const plugin of silgi.options.plugins) {
-    const pluginImportName = `_${hash(plugin.packageImport)}`;
-    _data.customImports.push(`import ${pluginImportName} from '${plugin.packageImport}'`);
+    const pluginImportName = hash(plugin.packageImport);
+    addImportItem({
+      specifier: plugin.packageImport,
+      imports: pluginImportName
+    });
     plugins.push(pluginImportName);
   }
   const importsContent = [
-    'import { mergeDeep } from "silgi/runtime"',
-    ...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}'`;
+    ...genImports.map(({ specifier, imports, options }) => {
+      return genImport(specifier, imports, options);
+    }),
+    ...genTypeImports.map(({ specifier, imports }) => {
+      return genTypeImport(specifier, Array.isArray(imports) ? imports : [imports]);
     }),
-    "",
-    ..._data.customImports,
     ""
   ];
   const importData = [
     "",
-    "export async function buildSilgi(framework: FrameworkContext, moduleOptions?: Partial<SilgiRuntimeOptions>,buildOptions?: Partial<SilgiOptions>) {",
+    "export async function buildSilgi(option: BuildSilgi) {",
+    "",
+    ...before,
     "",
-    _data.beforeBuildSilgiExtraContent.length > 0 ? _data.beforeBuildSilgiExtraContent.map(({ value, type }) => {
-      return type === "function" ? value : `const ${value}`;
-    }) : "",
+    "const silgi = await createSilgi({",
+    " framework: option.framework,",
+    " shared: shareds,",
+    " services: services,",
+    " schemas: schemas,",
+    " uris,",
+    " modulesURIs,",
+    ` plugins: [${plugins.join(", ")}],`,
     "",
-    "  const silgi = await createSilgi({",
-    "      framework,",
-    "      shared: shareds as any,",
-    "      services: services as any,",
-    "      schemas: schemas as any,",
-    "      uris,",
-    "      modulesURIs,",
-    `      plugins: [${plugins.join(", ")}],`,
-    _data._silgiConfigs.length > 0 ? `      ${_data._silgiConfigs.map((config) => typeof config === "string" ? config : typeof config === "object" ? Object.entries(config).map(([key, value]) => `${key}: ${value}`).join(",\n      ") : "").join(",\n      ")},` : "",
-    "      options: mergeDeep(cliConfigs, {",
-    "        runtimeConfig: {} as SilgiRuntimeOptions,",
-    "        routeRules: routeRules as any,",
-    `        present: '${silgi.options.preset}',`,
-    "        ...moduleOptions,",
-    "        ...buildOptions,",
-    "      }) as any,",
-    "    })",
+    _data.silgiConfigs.length > 0 ? _data.silgiConfigs.map((item) => {
+      const code = genObjectFromRawEntries(Object.entries(item));
+      return ` ${code.slice(1, -1).trim()},`;
+    }).filter(Boolean).join("\n") : "",
     "",
-    ...frameworkContext,
+    " options: mergeDeep(cliConfigs, {",
+    "   runtimeConfig: {} as SilgiRuntimeOptions,",
+    "   routeRules: routeRules as any,",
+    `   present: '${silgi.options.preset}',`,
+    "   ...option.modules,",
+    "   ...option.options,",
+    "   }) as any,",
+    " })",
     "",
-    ..._data.buildSilgiExtraContent,
+    ...after,
     "",
     "  return silgi",
     "}",
     ""
   ];
-  await silgi.callHook("after:prepare:core.ts", importData);
+  await silgi.callHook("after:core.ts", importData);
   importData.unshift(...importsContent);
   return importData;
 }
 
-async function prepareFramework(silgi) {
-  const importItems = {
-    "silgi/types": {
-      import: [
-        {
-          name: "SilgiRuntimeContext",
-          type: true,
-          key: "SilgiRuntimeContext"
-        }
-      ],
-      from: "silgi/types"
-    }
-  };
-  const customImports = [];
-  const functions = [];
-  await silgi.callHook("prepare:createCoreFramework", {
-    importItems,
-    customImports,
-    functions
-  });
-  const content = [
-    ...functions.map((f) => f.params?.length ? ` await ${f.name}(framework, ${f.params.join(",")})` : ` await ${f.name}(framework)`)
-  ];
-  return {
-    content,
-    importItems,
-    customImports
-  };
-}
-async function createDTSFramework(silgi) {
-  const importItems = {
-    "silgi/types": {
-      import: [
-        {
-          name: "SilgiRuntimeContext",
-          type: true,
-          key: "SilgiRuntimeContext"
-        }
-      ],
-      from: "silgi/types"
-    }
-  };
-  const customImports = [];
-  const customContent = [];
-  await silgi.callHook("prepare:createDTSFramework", {
-    importItems,
-    customImports,
-    customContent
-  });
-  const content = [
-    ...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}'`;
-    }),
-    "",
-    ...customImports,
-    "",
-    ...customContent,
-    ""
-  ];
-  return {
-    content,
-    importItems
-  };
-}
-
 async function writeCoreFile(silgi) {
-  const data = await prepareFramework(silgi);
-  const coreContent = await prepareCoreFile({
-    _importItems: data?.importItems ?? {},
-    _customImports: data?.customImports ?? []
-  }, data?.content ?? [], silgi);
+  const coreContent = await prepareCoreFile(silgi);
   const configs = await prepareConfigs(silgi);
   const silgiDir = resolve(silgi.options.silgi.serverDir);
   const buildFiles = [];
@@ -564,6 +536,46 @@ ${methodEntries}
   return context;
 }
 
+async function createDTSFramework(silgi) {
+  const importItems = {
+    "silgi/types": {
+      import: [
+        {
+          name: "SilgiRuntimeContext",
+          type: true,
+          key: "SilgiRuntimeContext"
+        }
+      ],
+      from: "silgi/types"
+    }
+  };
+  const customImports = [];
+  const customContent = [];
+  await silgi.callHook("prepare:createDTSFramework", {
+    importItems,
+    customImports,
+    customContent
+  });
+  const content = [
+    ...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}'`;
+    }),
+    "",
+    ...customImports,
+    "",
+    ...customContent,
+    ""
+  ];
+  return {
+    content,
+    importItems
+  };
+}
+
 async function prepareSchema(silgi) {
   const importItems = {
     "silgi/types": {
@@ -1049,8 +1061,9 @@ async function h3Framework(silgi, skip = false) {
       ""
     );
   });
-  silgi.hook("prepare:core.ts", (data) => {
-    data._silgiConfigs.push(`captureError: (silgi, error, context = {}) => {
+  silgi.hook("before:core.ts", (data) => {
+    data.createSilgiParams.push({
+      captureError: `(silgi, error, context = {}) => {
         const promise = silgi.hooks
           .callHookParallel('error', silgi, error, context)
           .catch((error_) => {
@@ -1066,7 +1079,8 @@ async function h3Framework(silgi, skip = false) {
             context.event.waitUntil(promise)
           }
         }
-      }`);
+      }`
+    });
   });
   if (silgi.options.imports !== false) {
     const h3Exports = await resolveModuleExportNames("h3", {

package/dist/kit/index.d.mts

@@ -1,4 +1,4 @@
-import { Commands, SilgiCLI, ModuleOptionsCustom, ModuleDefinition, SilgiModule, ServiceParseModule, SilgiPreset, SilgiPresetMeta, SilgiTemplate, ResolvedSilgiTemplate, SilgiEvents } from 'silgi/types';
+import { Commands, SilgiCLIHooks, SilgiCLI, ModuleOptionsCustom, ModuleDefinition, SilgiModule, ServiceParseModule, SilgiPreset, SilgiPresetMeta, SilgiTemplate, ResolvedSilgiTemplate, SilgiEvents } from 'silgi/types';
 import { Buffer } from 'node:buffer';
 import { ConsolaOptions, ConsolaInstance } from 'consola';
 import * as rfc6902 from 'rfc6902';
@@ -6,6 +6,11 @@ import { IncomingMessage, ServerResponse } from 'node:http';
 
 declare function addCommands(data: Commands | Commands[]): Promise<void>;
 
+declare function addCoreFile(data: {
+    before?: SilgiCLIHooks['before:core.ts'];
+    after?: SilgiCLIHooks['after:core.ts'];
+}): Promise<void>;
+
 declare function addNPMPackage(data: {
     name: string;
     version?: string;
@@ -296,5 +301,5 @@ declare function hasInstalledModule(moduleKey: string, silgi?: SilgiCLI): boolea
 declare const baseHeaderBannerComment: string[];
 declare function processFilePath(src: string): string;
 
-export { MODE_RE, MigrationStatus, addCommands, addNPMPackage, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, generateMigration, getAllEntries, getIpAddress, getMigration, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory, isH3, isNitro, isNuxt, listMigrations, migrationDown, migrationUp, normalizeTemplate, parseServices, prettyPath, processFilePath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, serviceParseModule, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };
+export { MODE_RE, MigrationStatus, addCommands, addCoreFile, addNPMPackage, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, generateMigration, getAllEntries, getIpAddress, getMigration, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory, isH3, isNitro, isNuxt, listMigrations, migrationDown, migrationUp, normalizeTemplate, parseServices, prettyPath, processFilePath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, serviceParseModule, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };
 export type { FunctionConfig, JsonPatch, MigrationData, MigrationInfo, MigrationOptions, MigrationResult };

package/dist/kit/index.mjs

@@ -67,6 +67,14 @@ async function addCommands(data) {
   });
 }
 
+async function addCoreFile(data) {
+  const silgi = useSilgiCLI$1();
+  if (data.before)
+    silgi.hook("before:core.ts", data.before);
+  if (data.after)
+    silgi.hook("after:core.ts", data.after);
+}
+
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function addNPMPackage(data) {
   const silgi = useSilgiCLI$1();
@@ -287,7 +295,7 @@ function getAllEntries(obj) {
 }
 
 function hash(data) {
-  return camelCase(hash$1(data));
+  return `_${camelCase(hash$1(data))}`;
 }
 
 function isNuxt() {
@@ -961,4 +969,4 @@ function isValidIp(ip) {
   return false;
 }
 
-export { MODE_RE, MigrationStatus, addCommands, addNPMPackage, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, generateMigration, getAllEntries, getIpAddress, getMigration, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory$1 as isDirectory, isH3, isNitro, isNuxt, listMigrations, migrationDown, migrationUp, normalizeTemplate, parseServices, prettyPath, processFilePath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, serviceParseModule, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };
+export { MODE_RE, MigrationStatus, addCommands, addCoreFile, addNPMPackage, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, generateMigration, getAllEntries, getIpAddress, getMigration, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory$1 as isDirectory, isH3, isNitro, isNuxt, listMigrations, migrationDown, migrationUp, normalizeTemplate, parseServices, prettyPath, processFilePath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, serviceParseModule, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };

package/dist/types/index.d.mts

@@ -14,6 +14,7 @@ import { H3Event } from 'h3';
 import { NitroRuntimeConfig } from 'nitropack/types';
 import { Defu } from 'defu';
 import { Stats } from 'node:fs';
+import { ESMImport, ESMCodeGenOptions } from 'knitwork';
 import { Unimport } from 'unimport';
 import { Storage, TransactionOptions, BuiltinDriverName, StorageValue } from 'unstorage';
 import { StandardSchemaV1 } from '@standard-schema/spec';
@@ -33,6 +34,9 @@ interface SilgiCompatibilityIssues extends Array<SilgiCompatibilityIssue> {
     toString: () => string;
 }
 
+/**
+ * @deprecated
+ */
 interface ImportItem {
     importItems: {
         [key: string]: {
@@ -161,6 +165,11 @@ interface Commands {
     }) => string;
     order?: number;
 }
+interface GenImport {
+    specifier: string;
+    imports: ESMImport | ESMImport[];
+    options?: ESMCodeGenOptions;
+}
 
 interface SilgiCLIHooks extends SilgiHooks {
     /**
@@ -200,8 +209,8 @@ interface SilgiCLIHooks extends SilgiHooks {
         declarations: string[];
         tsConfig: TSConfig;
     }) => HookResult;
-    'prepare:core.ts': (data: PrepareCore) => HookResult;
-    'after:prepare:core.ts': (content: string[]) => HookResult;
+    'before:core.ts': (data: PrepareCore) => HookResult;
+    'after:core.ts': (content: string[]) => HookResult;
     'prepare:scan.ts': (data: Pick<ImportItem, 'customImports' | 'importItems'> & {
         uris: Record<string, string>;
         services: string[];
@@ -290,14 +299,15 @@ interface SilgiHooks {
 interface GenerateAppOptions {
     filter?: (template: ResolvedSilgiTemplate<any>) => boolean;
 }
-interface PrepareCore extends ImportItem {
-    buildSilgiExtraContent: string[];
-    beforeBuildSilgiExtraContent: {
-        value: string;
-        type: 'function' | 'variable';
-    }[];
-    afterCliOptions: string[];
-    _silgiConfigs: any[];
+interface PrepareCore {
+    silgiConfigs: Record<string, any>[];
+    addImportItem: (data: GenImport | GenImport[]) => void;
+    addImportItemType: (data: GenImport | GenImport[]) => void;
+    addFunction: (data: {
+        name: string;
+        params?: string[];
+        where: 'before' | 'after';
+    }[]) => void;
 }
 
 /**
@@ -1030,7 +1040,7 @@ interface FrameworkContext {
 }
 interface Silgi {
     schemas: any;
-    services: ResolvedServiceType;
+    services: RequiredServiceType<SilgiSchema>;
     shared: SilgiRuntimeShareds;
     uris: Record<string, any>;
     modulesURIs: Partial<Record<keyof SilgiRuntimeOptions | (string & {}), any>>;
@@ -1057,6 +1067,11 @@ interface SilgiConfig extends Partial<Omit<Silgi, 'options'>>, Partial<SilgiRunt
 interface SilgiFunction {
     execute: <TURI extends keyof SilgiURIs>(uriString: TURI, input: ExtractInputFromURI<TURI>, source?: ExtractSourceFromURI<TURI>, queryParams?: Record<string, string>) => Promise<ExtractOutputFromURI<TURI>>;
 }
+interface BuildSilgi {
+    framework: FrameworkContext;
+    modules?: Partial<SilgiRuntimeOptions>;
+    options?: Partial<SilgiOptions>;
+}
 
 interface SilgiAppPlugin {
     (silgi: Silgi): Promise<void> | void;
@@ -1181,4 +1196,4 @@ interface ServiceParseModule {
     (params: ServiceParse): Awaited<void> | void;
 }
 
-export type { AllPaths, AppConfig, Awaitable, BaseNamespaceType, BaseSchemaType, BaseSilgiMethodType, CaptureError, CapturedErrorContext, CommandType, Commands, CreateScope, DeepPartial, DeepRequired, DefaultHooks, DefaultNamespaces, DefaultRouteConfig, DefaultRouteRules, DotenvOptions, EnvOptions, EventHandlerResponse, ExtendContext, ExtendShared, ExtractInputFromURI, ExtractOutputFromURI, ExtractPathParams, ExtractPathParamsFromURI, ExtractQueryParamsFromURI, ExtractSourceFromURI, FrameworkContext, GenerateAppOptions, GraphQLJSON, HookResult, HttpMethod, ImportItem, LoadConfigOptions, MergedSilgiSchema, MethodHandlerType, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, Namespaces, NitroBuildInfo, PrepareCore, RequiredServiceType, ResolvedMethodHandlerType, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedServiceType, ResolvedSilgiTemplate, RouteRules, RouterParams, ScanFile, ServiceParse, ServiceParseModule, ServiceType, Silgi, SilgiAppPlugin, SilgiCLI, SilgiCLIConfig, SilgiCLIDynamicConfig, SilgiCLIHooks, SilgiCLIOptions, SilgiCommands, SilgiCompatibility, SilgiCompatibilityIssue, SilgiCompatibilityIssues, SilgiConfig, SilgiEvents, SilgiFetchClient, SilgiFetchOptions, SilgiFrameworkInfo, SilgiFunction, SilgiHooks, SilgiModule, SilgiModuleInput, SilgiModuleOptions, SilgiNamespaces, SilgiOperation, SilgiOptions, SilgiPreset, SilgiPresetMeta, SilgiRouteRules, SilgiRouterTypes, SilgiRuntimeActions, SilgiRuntimeConfig, SilgiRuntimeContext, SilgiRuntimeHooks, SilgiRuntimeMethods, SilgiRuntimeOptions, SilgiRuntimeRouteRules, SilgiRuntimeRouteRulesConfig, SilgiRuntimeShareds, SilgiRuntimeSharedsExtend, SilgiSchema, SilgiServiceInterface, SilgiStorageBase, SilgiTemplate, SilgiURIs, StorageConfig, StorageKeyGenerator, StorageKeyParams, StorageMounts, TSReference, TrimAfterFourSlashes, URIsTypes };
+export type { AllPaths, AppConfig, Awaitable, BaseNamespaceType, BaseSchemaType, BaseSilgiMethodType, BuildSilgi, CaptureError, CapturedErrorContext, CommandType, Commands, CreateScope, DeepPartial, DeepRequired, DefaultHooks, DefaultNamespaces, DefaultRouteConfig, DefaultRouteRules, DotenvOptions, EnvOptions, EventHandlerResponse, ExtendContext, ExtendShared, ExtractInputFromURI, ExtractOutputFromURI, ExtractPathParams, ExtractPathParamsFromURI, ExtractQueryParamsFromURI, ExtractSourceFromURI, FrameworkContext, GenImport, GenerateAppOptions, GraphQLJSON, HookResult, HttpMethod, ImportItem, LoadConfigOptions, MergedSilgiSchema, MethodHandlerType, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, Namespaces, NitroBuildInfo, PrepareCore, RequiredServiceType, ResolvedMethodHandlerType, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedServiceType, ResolvedSilgiTemplate, RouteRules, RouterParams, ScanFile, ServiceParse, ServiceParseModule, ServiceType, Silgi, SilgiAppPlugin, SilgiCLI, SilgiCLIConfig, SilgiCLIDynamicConfig, SilgiCLIHooks, SilgiCLIOptions, SilgiCommands, SilgiCompatibility, SilgiCompatibilityIssue, SilgiCompatibilityIssues, SilgiConfig, SilgiEvents, SilgiFetchClient, SilgiFetchOptions, SilgiFrameworkInfo, SilgiFunction, SilgiHooks, SilgiModule, SilgiModuleInput, SilgiModuleOptions, SilgiNamespaces, SilgiOperation, SilgiOptions, SilgiPreset, SilgiPresetMeta, SilgiRouteRules, SilgiRouterTypes, SilgiRuntimeActions, SilgiRuntimeConfig, SilgiRuntimeContext, SilgiRuntimeHooks, SilgiRuntimeMethods, SilgiRuntimeOptions, SilgiRuntimeRouteRules, SilgiRuntimeRouteRulesConfig, SilgiRuntimeShareds, SilgiRuntimeSharedsExtend, SilgiSchema, SilgiServiceInterface, SilgiStorageBase, SilgiTemplate, SilgiURIs, StorageConfig, StorageKeyGenerator, StorageKeyParams, StorageMounts, TSReference, TrimAfterFourSlashes, URIsTypes };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.29.7",
+  "version": "0.29.9",
   "private": false,
   "sideEffects": false,
   "exports": {
@@ -15,10 +15,22 @@
     "./config": "./lib/config.mjs",
     "./types": "./dist/types/index.d.mts",
     "./meta": "./lib/meta.mjs",
-    "./presets": "./dist/presets/index.mjs",
-    "./runtime": "./dist/runtime/index.mjs",
-    "./runtime/internal": "./dist/runtime/internal/index.mjs",
-    "./runtime/internal/*": "./dist/runtime/internal/*.mjs",
+    "./presets": {
+      "import": "./dist/presets/index.mjs",
+      "silgiDev": "./dist/presets/index.ts"
+    },
+    "./runtime": {
+      "import": "./dist/runtime/index.mjs",
+      "silgiDev": "./dist/runtime/index.ts"
+    },
+    "./runtime/internal/nitro": {
+      "import": "./dist/runtime/internal/nitro.mjs",
+      "silgiDev": "./dist/runtime/internal/nitro.ts"
+    },
+    "./runtime/internal": {
+      "import": "./dist/runtime/internal/index.mjs",
+      "silgiDev": "./dist/runtime/internal/index.ts"
+    },
     "./runtime/meta": "./lib/runtime-meta.mjs"
   },
   "main": "./dist/core/index.mjs",
@@ -89,6 +101,7 @@
     "ignore": "^7.0.3",
     "klona": "^2.0.6",
     "knitwork": "^1.2.0",
+    "magicast": "^0.3.5",
     "mlly": "^1.7.4",
     "ofetch": "^1.4.1",
     "ohash": "^2.0.11",

package/dist/cli/run.mjs

@@ -1,209 +0,0 @@
-import { execSync } from 'node:child_process';
-import * as p from '@clack/prompts';
-import { isCancel, cancel } from '@clack/prompts';
-import { defineCommand, runCommand } from 'citty';
-import { consola } from 'consola';
-import { createJiti } from 'dev-jiti';
-import { useSilgiCLI as useSilgiCLI$1 } from 'silgi';
-import { version } from 'silgi/meta';
-import { u as useSilgiCLI, a as silgiCLIIClose } from '../_chunks/silgiApp.mjs';
-import { addTemplate } from 'silgi/kit';
-import { generateTypes, resolveSchema } from 'untyped';
-import { c as commonArgs, p as prepare } from './prepare.mjs';
-import { p as prepareEnv } from './silgi.mjs';
-import { l as loadOptions } from './types.mjs';
-import 'unctx';
-import 'pathe';
-import 'apiful/openapi';
-import 'node:fs';
-import 'node:fs/promises';
-import 'knitwork';
-import 'mlly';
-import 'pathe/utils';
-import 'silgi/runtime/meta';
-import 'unimport';
-import 'hookable';
-import '../_chunks/routeRules.mjs';
-import 'ufo';
-import 'dotenv';
-import './compatibility.mjs';
-import 'semver/functions/satisfies.js';
-import 'node:url';
-import 'defu';
-import 'exsolve';
-import 'globby';
-import 'ignore';
-import '@oxc-parser/wasm';
-import 'klona';
-import 'silgi/runtime';
-import 'unstorage';
-import 'scule';
-import 'c12';
-import 'compatx';
-import 'klona/full';
-import 'std-env';
-import 'consola/utils';
-import 'escape-string-regexp';
-import 'pkg-types';
-
-function debugMode(name) {
-  const silgi = useSilgiCLI();
-  if (silgi.options.debug === true || typeof silgi.options.debug === "object" && silgi.options.debug[name]) {
-    return true;
-  }
-  return false;
-}
-
-async function scanCommands(silgi = useSilgiCLI()) {
-  const commands = [];
-  await silgi.callHook("prepare:commands", commands);
-  if (debugMode("command")) {
-    addTemplate({
-      filename: "cli.json",
-      where: ".silgi",
-      write: true,
-      getContents: () => JSON.stringify(commands, null, 2)
-    });
-  }
-  silgi.hook("prepare:schema.ts", async (object) => {
-    const allTags = commands.reduce((acc, commandGroup) => {
-      Object.values(commandGroup).forEach((command) => {
-        if (command.tags) {
-          command.tags.forEach((tag) => acc.add(tag));
-        }
-      });
-      return acc;
-    }, /* @__PURE__ */ new Set());
-    const data = [
-      "",
-      generateTypes(
-        await resolveSchema(
-          {
-            ...Object.fromEntries(Array.from(allTags.values()).map((tag) => [tag, "string"]))
-          }
-        ),
-        {
-          interfaceName: "SilgiCommandsExtended",
-          addExport: false,
-          addDefaults: false,
-          allowExtraKeys: false,
-          indentation: 0
-        }
-      ),
-      ""
-    ];
-    object.customImports?.push(...data);
-  });
-  return commands;
-}
-
-function cancelOnCancel({
-  value,
-  message = "Cancelled",
-  onBeforeExit,
-  exitCode = 0
-} = {}) {
-  const handleCancel = () => {
-    cancel(message);
-    onBeforeExit?.();
-    process.exit(exitCode);
-  };
-  if (!value || isCancel(value))
-    handleCancel();
-}
-
-const run = defineCommand({
-  meta: {
-    name: "run",
-    description: "Run a command from the CLI",
-    version: version
-  },
-  args: {
-    ...commonArgs,
-    preset: {
-      type: "string",
-      description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
-    },
-    tag: {
-      type: "string"
-    },
-    active: {
-      type: "boolean",
-      description: "Run in silgi development mode",
-      default: true
-    }
-  },
-  async run({ args }) {
-    const data = args.active ? await runCommand(prepare, {
-      rawArgs: ["--commandType", "run"]
-    }) : void 0;
-    const silgi = useSilgiCLI$1();
-    const commands = await scanCommands();
-    globalThis.__nitro__ = globalThis.__nitro__ || {};
-    globalThis.__nitro__.useRuntimeConfig = function() {
-      return data?.result?.silgi?.options?.runtimeConfig || {};
-    };
-    if (!data?.result?.silgi && args.active) {
-      consola.error("Silgi not found");
-      return;
-    }
-    const tags = args.tag?.split(",").map((t) => t.trim());
-    const silgiConfig = await loadOptions({});
-    await prepareEnv(silgiConfig);
-    let selectedCommands = [];
-    if (tags?.length) {
-      selectedCommands = commands.filter((cmd) => cmd.tags?.some((tag) => tags.includes(tag))).filter((cmd) => cmd.when !== false);
-    } else {
-      selectedCommands = commands.filter((cmd) => cmd.when !== false);
-    }
-    const multiSelect = await p.groupMultiselect({
-      message: "Select commands to run",
-      required: true,
-      options: {
-        ...selectedCommands.sort((a, b) => (a.order || Infinity) - (b.order || Infinity)).reduce((acc, cmd) => {
-          if (!acc[cmd.group || ""]) {
-            acc[cmd.group || ""] = [];
-          }
-          acc[cmd.group || ""].push({
-            label: cmd.name,
-            value: cmd,
-            hint: cmd.description
-          });
-          return acc;
-        }, {})
-      }
-    });
-    cancelOnCancel({ value: multiSelect });
-    selectedCommands = multiSelect;
-    const spinner = p.spinner({
-      indicator: "dots"
-    });
-    for (const cmd of selectedCommands) {
-      const data2 = cmd.getContents({ app: silgi });
-      spinner.start(`[${cmd.group}] ${cmd.name}...`);
-      if (cmd.type === "command") {
-        execSync(data2, { stdio: "inherit" });
-      }
-      if (cmd.type === "function") {
-        const jiti = createJiti(import.meta.url, {
-          alias: silgiConfig.alias
-        });
-        let cleanHandler = cmd.getContents({ app: silgi }).replace(/\n/g, "");
-        cleanHandler = `import { silgiCLICtx } from 'silgi' 
-        ${cleanHandler}
-`;
-        await jiti.evalModule(cleanHandler, {
-          filename: import.meta.url,
-          async: true,
-          conditions: silgiConfig.conditions,
-          forceTranspile: true
-        });
-      }
-      spinner.stop();
-      consola.success(`[${cmd.group}] ${cmd.name} done`);
-    }
-    await silgiCLIIClose();
-  }
-});
-
-export { run as default };