silgi 0.28.10 → 0.28.12

package/dist/cli/dev.mjs

@@ -46,7 +46,6 @@ import 'silgi/runtime';
 import 'unstorage';
 import 'scule';
 import 'node:child_process';
-import 'picocolors';
 
 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.28.10";
+const version = "0.28.12";
 const packageJson = {
 	version: version};
 
@@ -24,9 +24,7 @@ const main = defineCommand({
     install: () => import('./install.mjs').then((m) => m.default),
     dev: () => import('./dev.mjs').then((m) => m.default)
   },
-  run({ args }) {
-    if (args.version)
-      console.warn("Silgi version:", packageJson.version);
+  run() {
   }
 });
 runMain(main);

package/dist/cli/init.mjs

@@ -42,7 +42,6 @@ import 'silgi/runtime';
 import 'unstorage';
 import 'scule';
 import 'node:child_process';
-import 'picocolors';
 import '../_chunks/silgiApp.mjs';
 import 'unctx';
 

package/dist/cli/install.mjs

@@ -4,11 +4,13 @@ import { defineCommand, runCommand } from 'citty';
 import { consola } from 'consola';
 import { resolve } from 'pathe';
 import { version } from 'silgi/meta';
+import { addNPMPackage, addTemplate } from 'silgi/kit';
+import { u as useSilgiCLI } from '../_chunks/silgiApp.mjs';
 import { a as commonArgs, c as command$1 } from './prepare.mjs';
 import { l as loadOptions } from './types.mjs';
+import 'unctx';
 import './silgi.mjs';
 import 'apiful/openapi';
-import 'silgi/kit';
 import 'node:fs/promises';
 import 'knitwork';
 import 'mlly';
@@ -35,9 +37,6 @@ import 'klona';
 import 'silgi/runtime';
 import 'unstorage';
 import 'scule';
-import 'picocolors';
-import '../_chunks/silgiApp.mjs';
-import 'unctx';
 import 'c12';
 import 'compatx';
 import 'klona/full';
@@ -46,6 +45,44 @@ import 'consola/utils';
 import 'escape-string-regexp';
 import 'pkg-types';
 
+async function installPackages(silgi = useSilgiCLI()) {
+  await addNPMPackage([
+    {
+      name: "@fastify/deepmerge",
+      isDev: false
+    },
+    {
+      name: "@silgi/ecosystem",
+      isDev: false
+    },
+    {
+      name: "unadapter",
+      isDev: false
+    }
+  ]);
+  const packages = {
+    dependencies: {
+      ...silgi.options.installPackages?.dependencies
+    },
+    devDependencies: {
+      ...silgi.options.installPackages?.devDependencies
+    }
+  };
+  if (silgi.options.preset === "npm-package") {
+    packages.devDependencies = {
+      ...packages.devDependencies,
+      ...packages.dependencies
+    };
+    packages.dependencies = {};
+  }
+  addTemplate({
+    filename: "install.json",
+    where: ".silgi",
+    write: true,
+    getContents: () => JSON.stringify(packages, null, 2)
+  });
+}
+
 const command = defineCommand({
   meta: {
     name: "install",
@@ -64,6 +101,7 @@ const command = defineCommand({
       rawArgs: []
     }).catch(() => {
     });
+    await installPackages();
     const silgiConfig = await loadOptions({});
     const commandArgs = process.argv.slice(process.argv.indexOf("install") + 1);
     const extraArgs = commandArgs.length ? ` ${commandArgs.join(" ")}` : "";

package/dist/cli/prepare.mjs

@@ -3,13 +3,14 @@ import { resolve } from 'pathe';
 import { version } from 'silgi/meta';
 import { p as prepareEnv, c as createSilgiCLI, b as build } from './silgi.mjs';
 import { execSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
 import * as p from '@clack/prompts';
+import { isCancel, cancel } from '@clack/prompts';
 import { consola } from 'consola';
 import { createJiti } from 'dev-jiti';
-import color from 'picocolors';
-import { useSilgiCLI } from 'silgi';
-import { a as silgiCLIIClose } from '../_chunks/silgiApp.mjs';
+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 = {
@@ -24,6 +25,72 @@ 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 command$1 = defineCommand({
   meta: {
     name: "run",
@@ -49,192 +116,53 @@ const command$1 = defineCommand({
     const data = args.active ? await runCommand(command, {
       rawArgs: ["--commands", "run"]
     }) : void 0;
-    globalThis.__nitro__ = globalThis.__nitro__ || {};
-    globalThis.__nitro__.useRuntimeConfig = function() {
-      return data?.result?.silgi?.options?.runtimeConfig || {};
-    };
+    const silgi = useSilgiCLI$1();
+    const commands = await scanCommands();
     if (!data?.result?.silgi && args.active) {
       consola.error("Silgi not found");
       return;
     }
-    const silgi = useSilgiCLI();
     const tags = args.tag?.split(",").map((t) => t.trim());
-    p.intro(color.bold(`Silgi CLI ${color.green(`v${version}`)}`));
     const silgiConfig = await loadOptions({});
-    const getCli = resolve(silgiConfig.build.dir, "cli.json");
-    const cli = readFileSync(getCli, "utf-8");
-    const cliJson = JSON.parse(cli);
     await prepareEnv(silgiConfig);
     let selectedCommands = [];
-    if (tags) {
-      for (const commandName of Object.keys(cliJson)) {
-        const scripts = cliJson[commandName];
-        for (const scriptName of Object.keys(scripts)) {
-          const script = scripts[scriptName];
-          if (script.tags && script.tags.some((tag) => tags.includes(tag))) {
-            selectedCommands.push({
-              command: commandName,
-              script: scriptName,
-              handler: script
-            });
-          }
-        }
-      }
-      if (selectedCommands.length === 0) {
-        return;
-      }
+    if (tags?.length) {
+      selectedCommands = commands.filter((cmd) => cmd.tags?.some((tag) => tags.includes(tag))).filter((cmd) => cmd.when !== false);
     } else {
-      if (!silgi) {
-        consola.error("Silgi not found");
-        return;
-      }
-      if (Object.keys(cliJson).length === 0) {
-        consola.warn("No commands found in cli.json");
-        return;
-      }
-      const allTags = Object.values(silgi.commands).reduce((acc, commandGroup) => {
-        Object.values(commandGroup).forEach((command2) => {
-          if (command2.tags) {
-            command2.tags.forEach((tag) => acc.add(tag));
-          }
-        });
-        return acc;
-      }, /* @__PURE__ */ new Set());
-      const commandName = await p.select({
-        message: "Select a command to run",
-        options: [
-          ...allTags.size ? [{
-            value: "command-tags",
-            label: "Command Tags",
-            hint: "It executes all commands that are related to the tags you select."
-          }] : [],
-          {
-            value: "functions",
-            label: "Functions",
-            hint: "Select and run individual functions"
-          },
-          ...Object.keys(cliJson).filter((key) => {
-            const scripts = cliJson[key];
-            const scriptValues = Object.values(scripts);
-            return scriptValues;
-          }).map((key) => ({
-            label: key,
-            value: key
-          }))
-        ]
-      });
-      if (!commandName)
-        return;
-      if (commandName === "command-tags") {
-        const tags2 = Array.from(allTags);
-        const selectedTags = await p.select({
-          message: "Select tags to run",
-          options: tags2.map((tag) => ({
-            label: tag,
-            value: tag
-          }))
-        });
-        if (!selectedTags)
-          return;
-        selectedCommands = Object.keys(cliJson).map(
-          (commandName2) => {
-            const scripts = cliJson[commandName2];
-            return Object.keys(scripts).map((scriptName) => ({
-              command: commandName2,
-              script: scriptName,
-              handler: scripts[scriptName]
-            })).filter((script) => script.handler.tags?.includes(selectedTags));
-          }
-        ).flat();
-      } else if (commandName === "functions") {
-        const functionGroups = Object.keys(cliJson).reduce((groups, cmdName) => {
-          const scripts2 = cliJson[cmdName];
-          if (!Object.values(scripts2).some((script) => script.type === "function")) {
-            return groups;
-          }
-          groups.push(cmdName);
-          return groups;
-        }, []);
-        if (functionGroups.length === 0) {
-          consola.warn("No function groups found in cli.json");
-          return;
-        }
-        const selectedGroup = await p.select({
-          message: "Select a project group",
-          options: functionGroups.map((group) => ({
-            label: group,
-            value: group
-          }))
-        });
-        if (!selectedGroup)
-          return;
-        const availableFunctions = [];
-        const scripts = cliJson[selectedGroup];
-        for (const scriptName of Object.keys(scripts)) {
-          const script = scripts[scriptName];
-          if (script && script.type === "function") {
-            availableFunctions.push({
-              command: selectedGroup,
-              script: scriptName,
-              handler: script
-            });
-          }
-        }
-        if (availableFunctions.length === 0) {
-          consola.warn(`No functions found in the ${selectedGroup} group`);
-          return;
-        }
-        const selectedFunction = await p.select({
-          message: `Select a function from ${selectedGroup}`,
-          options: availableFunctions.map((fn, index) => ({
-            label: fn.script,
-            value: index.toString(),
-            hint: fn.handler.description || void 0
-          }))
-        });
-        if (!selectedFunction)
-          return;
-        const selectedIndex = Number.parseInt(selectedFunction, 10);
-        const selectedFunctionObj = availableFunctions[selectedIndex];
-        if (!selectedFunctionObj || !selectedFunctionObj.handler) {
-          consola.error("Selected function not found or invalid");
-          return;
-        }
-        selectedCommands = [{
-          command: selectedFunctionObj.command,
-          script: selectedFunctionObj.script,
-          handler: selectedFunctionObj.handler
-        }];
-      } else {
-        const scripts = cliJson[commandName];
-        const scriptName = await p.select({
-          message: "Select a script to run",
-          options: Object.keys(scripts).filter((key) => !scripts[key].tags?.length).map((key) => ({
-            label: key,
-            value: key
-          }))
-        });
-        if (!scriptName)
-          return;
-        selectedCommands = [{
-          command: commandName,
-          script: scriptName,
-          handler: scripts[scriptName]
-        }];
-      }
+      selectedCommands = commands.filter((cmd) => cmd.when !== false);
     }
-    for (const cmd of selectedCommands) {
-      if (cmd.handler.enabled === false) {
-        continue;
+    const multiSelect = await p.groupMultiselect({
+      message: "Select commands to run",
+      required: true,
+      options: {
+        ...selectedCommands.reduce((acc, cmd) => {
+          acc[cmd.group || ""] = [
+            {
+              label: cmd.name,
+              value: cmd,
+              hint: cmd.description
+            }
+          ];
+          return acc;
+        }, {})
       }
-      if (cmd.handler.type === "command") {
-        execSync(cmd.handler.handler, { stdio: "inherit" });
+    });
+    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.handler.type === "function") {
+      if (cmd.type === "function") {
         const jiti = createJiti(import.meta.url, {
           alias: silgiConfig.alias
         });
-        let cleanHandler = cmd.handler.handler.replace(/\n/g, "");
+        let cleanHandler = cmd.getContents({ app: silgi }).replace(/\n/g, "");
         cleanHandler = `import { silgiCLICtx } from 'silgi' 
         ${cleanHandler}
 `;
@@ -245,6 +173,8 @@ const command$1 = defineCommand({
           forceTranspile: true
         });
       }
+      spinner.stop();
+      consola.success(`[${cmd.group}] ${cmd.name} done`);
     }
     await silgiCLIIClose();
   }

package/dist/cli/silgi.mjs

@@ -1,7 +1,7 @@
 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, addNPMPackage, resolveSilgiPath } from 'silgi/kit';
+import { hasSilgiModule, addTemplate, normalizeTemplate, useLogger, genEnsureSafeVar, hash, relativeWithDot, writeFile, 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';
@@ -1534,49 +1534,6 @@ ${cycleStr}`);
   return order;
 }
 
-async function commands(silgi) {
-  const commands2 = {
-    ...silgi.options.commands
-  };
-  await silgi.callHook("prepare:commands", commands2);
-  addTemplate({
-    filename: "cli.json",
-    where: ".silgi",
-    write: true,
-    getContents: () => JSON.stringify(commands2, null, 2)
-  });
-  silgi.commands = commands2;
-  silgi.hook("prepare:schema.ts", async (object) => {
-    const allTags = Object.values(commands2).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);
-  });
-}
-
 function resolveIgnorePatterns(silgi, relativePath) {
   if (!silgi) {
     return [];
@@ -2188,45 +2145,6 @@ async function createStorageCLI(silgi) {
   return storage;
 }
 
-async function installPackages(silgi) {
-  await addNPMPackage([
-    {
-      name: "@fastify/deepmerge",
-      isDev: false
-    },
-    {
-      name: "@silgi/ecosystem",
-      isDev: false
-    },
-    {
-      name: "unadapter",
-      isDev: false
-    }
-  ]);
-  const packages = {
-    dependencies: {
-      ...silgi.options.installPackages?.dependencies
-    },
-    devDependencies: {
-      ...silgi.options.installPackages?.devDependencies
-    }
-  };
-  console.log(packages);
-  if (silgi.options.preset === "npm-package") {
-    packages.devDependencies = {
-      ...packages.devDependencies,
-      ...packages.dependencies
-    };
-    packages.dependencies = {};
-  }
-  addTemplate({
-    filename: "install.json",
-    where: ".silgi",
-    write: true,
-    getContents: () => JSON.stringify(packages, null, 2)
-  });
-}
-
 function useCLIRuntimeConfig(silgi) {
   const safeRuntimeConfig = JSON.parse(JSON.stringify(silgi.options.runtimeConfig));
   silgi.hook("prepare:configs.ts", (data) => {
@@ -2345,7 +2263,6 @@ async function createSilgiCLI(config = {}, opts = {}) {
     options,
     hooks,
     errors: [],
-    commands: {},
     _requiredModules: {},
     logger: consola.withTag("silgi"),
     close: () => silgi.hooks.callHook("close", silgi),
@@ -2402,8 +2319,6 @@ async function createSilgiCLI(config = {}, opts = {}) {
   silgi.hooks.addHooks(silgi.options.hooks);
   await installModules(silgi);
   await silgi.hooks.callHook("scanFiles:done", silgi);
-  await commands(silgi);
-  await installPackages(silgi);
   await generateApp(silgi);
   if (silgi.options.imports) {
     silgi.options.imports.dirs ??= [];

package/dist/cli/types.mjs

@@ -126,7 +126,6 @@ const SilgiCLIDefaults = {
   conditions: [],
   nodeModulesDirs: [],
   hooks: {},
-  commands: {},
   // Framework
   framework: {
     name: "h3",

package/dist/kit/index.d.mts

@@ -269,7 +269,6 @@ declare function getIpAddress(event: SilgiEvents): string | boolean;
 declare function ipAddress(req: IncomingMessage): string;
 
 declare function relativeWithDot(from: string, to: string): string;
-/** @since 3.9.0 */
 declare function toArray<T>(value: T | T[]): T[];
 /**
  * Filter out items from an array in place. This function mutates the array.

package/dist/kit/index.mjs

@@ -22,6 +22,7 @@ import 'unctx';
 import 'semver/functions/satisfies.js';
 import 'silgi/meta';
 
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function addNPMPackage(data) {
   const silgi = useSilgiCLI();
   for (const item of data) {
@@ -32,6 +33,11 @@ async function addNPMPackage(data) {
       `pnpm info ${item.name} version`,
       { encoding: "utf-8" }
     );
+    silgi.logger.withTag("add-npm").success(
+      "Checking package version",
+      item.name,
+      getPackageVersion.trim()
+    );
     let version = item.version || getPackageVersion.trim();
     version = `^${version}`;
     if (item.isDev) {
@@ -39,6 +45,7 @@ async function addNPMPackage(data) {
     } else {
       silgi.options.installPackages.dependencies[item.name] = version;
     }
+    await delay(50);
   }
 }
 

package/dist/types/index.d.mts

@@ -47,8 +47,6 @@ interface ImportItem {
     customImports: string[];
     customContent?: string[];
 }
-interface SilgiCommands {
-}
 interface SilgiCLI {
     _ignore?: Ignore;
     errors: {
@@ -82,13 +80,6 @@ interface SilgiCLI {
     }>;
     options: SilgiCLIOptions;
     _requiredModules: Record<string, boolean>;
-    commands: Record<string, Record<string, {
-        type: 'function' | 'command';
-        handler: string;
-        description?: string;
-        tags?: (keyof SilgiCommands)[];
-        enabled?: boolean;
-    }>>;
     adapters: Record<string, Adapter<Record<string, any>, TablesSchema, InferModelTypes<TablesSchema>>>;
 }
 type SilgiCLIDynamicConfig = Pick<SilgiCLIConfig, 'routeRules'>;
@@ -605,7 +596,9 @@ interface SilgiCLIOptions extends PresetOptions {
     modules: (SilgiModule<any> | string | [SilgiModule | string, Record<string, any>] | undefined | null | false)[];
     _modules: (SilgiModule<any> | string | [SilgiModule | string, Record<string, any>] | undefined | null | false)[];
     isPreparingModules: boolean;
-    debug: boolean;
+    debug: true | {
+        command?: boolean;
+    };
     preset: PresetName;
     static: boolean;
     logLevel: LogLevel;
@@ -805,11 +798,6 @@ interface SilgiCLIOptions extends PresetOptions {
      * ```
      */
     ignoreOptions: Options;
-    commands: Record<string, Record<string, {
-        type: 'function' | 'command';
-        handler: string;
-        description?: string;
-    }>>;
     installPackages: Record<'dependencies' | 'devDependencies', Record<string, string>>;
     apiFul: ApifulConfig;
     adapters: Record<string, Adapter<Record<string, any>, TablesSchema, InferModelTypes<TablesSchema>>>;
@@ -1159,6 +1147,20 @@ interface GraphQLJSON {
     references: any;
 }
 
+interface SilgiCommands {
+}
+interface Commands {
+    name: string;
+    description?: string;
+    group: string;
+    when?: boolean;
+    type: 'function' | 'command';
+    tags?: (keyof SilgiCommands)[] | (string | object)[];
+    getContents: (data: {
+        app: SilgiCLI;
+    }) => string;
+}
+
 interface BaseNamespaceType extends Record<keyof DefaultNamespaces, Record<string, BaseSchemaType<StandardSchemaV1>>> {
 }
 type Namespaces<T extends BaseNamespaceType> = {
@@ -1178,4 +1180,4 @@ interface ServiceParseModule {
     (params: ServiceParse): Awaited<void> | void;
 }
 
-export type { AllPaths, AppConfig, Awaitable, BaseNamespaceType, BaseSchemaType, BaseSilgiMethodType, CaptureError, CapturedErrorContext, CommandType, 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, 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 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.28.10",
+  "version": "0.28.12",
   "private": false,
   "sideEffects": false,
   "exports": {