silgi 0.39.15 → 0.40.0

package/dist/build.mjs

@@ -29,9 +29,9 @@ import 'node:fs/promises';
 import 'oxc-parser';
 import 'tinyglobby';
 import 'ignore';
+import 'scule';
 import 'klona';
 import 'unstorage';
-import 'scule';
 import './cli/loader.mjs';
 import 'c12';
 import 'compatx';

package/dist/cli/build.mjs

@@ -2,8 +2,8 @@ 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, genEnsureSafeVar, getServicePath, writeFile, relativeWithDot, hash, removeExtension, resolveAlias, directoryToURL, addImports, baseHeaderBannerComment, normalizeTemplate, useLogger, resolveSilgiPath, hasSilgiModule, toArray, isDirectory } from 'silgi/kit';
-import { useRuntimeConfig, initRuntimeConfig, sharedRuntimeConfig } from 'silgi/runtime';
+import { isPresents, addTemplate, addCoreFile, genEnsureSafeVar, getServicePath, writeFile, relativeWithDot, hash, removeExtension, resolveAlias, directoryToURL, baseHeaderBannerComment, addImports, normalizeTemplate, useLogger, resolveSilgiPath, hasSilgiModule, toArray, isDirectory } from 'silgi/kit';
+import { initRuntimeConfig, useRuntimeConfig, sharedRuntimeConfig } from 'silgi/runtime';
 import { runtimeDir } from 'silgi/runtime/meta';
 import { scanExports, createUnimport, toExports } from 'unimport';
 import * as p from '@clack/prompts';
@@ -21,9 +21,9 @@ import { readdir, readFile } from 'node:fs/promises';
 import { parseAsync } from 'oxc-parser';
 import { glob } from 'tinyglobby';
 import ignore from 'ignore';
+import { snakeCase } from 'scule';
 import { klona } from 'klona';
 import { createStorage, builtinDrivers } from 'unstorage';
-import { snakeCase } from 'scule';
 import { l as loadOptions } from './loader.mjs';
 import { generateDTS } from 'apiful/openapi';
 import { u as useSilgiCLI$1 } from '../_chunks/silgiApp.mjs';
@@ -252,7 +252,7 @@ async function nextJS(silgi, skip = false) {
     write: true,
     getContents: () => template.join("\n")
   });
-  silgi.hook("scanFiles:done", async (silgi2) => {
+  silgi.hook("ready", async (silgi2) => {
     const routerPrefixs = [];
     for (const _route in silgi2.services) {
       const { route } = getServicePath(_route);
@@ -1044,62 +1044,116 @@ ${cycleStr}`);
   return order;
 }
 
-async function readScanFile(silgi) {
-  const path = resolve(silgi.options.silgi.serverDir, "scan.ts");
-  const context = await promises.readFile(path, { encoding: "utf-8" });
-  silgi.unimport = createUnimport(silgi.options.imports || {});
-  await silgi.unimport.init();
-  const injectedResult = await silgi.unimport.injectImports(context, path);
-  if (!injectedResult) {
-    throw new Error("Failed to inject imports");
-  }
-  const jiti = createJiti(silgi.options.rootDir, {
-    fsCache: true,
-    moduleCache: false,
-    debug: silgi.options.debug === true,
-    alias: silgi.options.alias
+function useCLIRuntimeConfig(silgi = useSilgiCLI()) {
+  const safeRuntimeConfig = JSON.parse(JSON.stringify(silgi.options.runtimeConfig));
+  silgi.hook("prepare:configs.ts", (data) => {
+    data.runtimeConfig = safeRuntimeConfig;
+    silgi.options.envOptions = silgi.options.envOptions;
   });
-  try {
-    const scanFile = await jiti.evalModule(
-      injectedResult.code,
-      {
-        filename: path,
-        async: true,
-        conditions: silgi.options.conditions
-      },
-      async (data, name) => {
-        return (await silgi.unimport.injectImports(data, name)).code;
+  addTemplate({
+    filename: "env.example",
+    write: true,
+    where: ".silgi",
+    getContents() {
+      const flattenedConfig = flattenObject(safeRuntimeConfig);
+      const groupedVars = {};
+      Object.entries(flattenedConfig).forEach(([key, { value, originalPath }]) => {
+        const shouldExclude = silgi.options.codegen.env.safeList.some((safePath) => {
+          if (safePath.length !== originalPath.length)
+            return false;
+          return safePath.every((segment, index) => segment.toLowerCase() === originalPath[index].toLowerCase());
+        });
+        if (shouldExclude)
+          return;
+        if (originalPath.length > 0) {
+          const firstKey = originalPath[0];
+          const categoryName = extractCategoryFromCamel(firstKey);
+          if (!groupedVars[categoryName]) {
+            groupedVars[categoryName] = {};
+          }
+          groupedVars[categoryName][key] = value;
+        } else {
+          if (!groupedVars.OTHER) {
+            groupedVars.OTHER = {};
+          }
+          groupedVars.OTHER[key] = value;
+        }
+      });
+      return Object.entries(groupedVars).map(([category, vars]) => {
+        const varsContent = Object.entries(vars).map(([key, value]) => `${key}=${value}`).join("\n");
+        return `# ${category}
+${varsContent}`;
+      }).join("\n\n");
+    }
+  });
+  const _sharedRuntimeConfig = initRuntimeConfig(silgi.options.envOptions, silgi.options.runtimeConfig);
+  silgi.options.runtimeConfig = safeRuntimeConfig;
+  return _sharedRuntimeConfig;
+}
+function extractCategoryFromCamel(str) {
+  if (/^[a-z]+[A-Z]/.test(str)) {
+    const matches = str.match(/^([a-z]+)([A-Z][a-z0-9]*)?/);
+    if (matches && matches[2]) {
+      return `${matches[1].toUpperCase()}_${matches[2].toUpperCase()}`;
+    }
+  }
+  return str.toUpperCase();
+}
+function flattenObject(obj, prefix = "SILGI", originalPath = []) {
+  return Object.entries(obj).reduce((acc, [key, value]) => {
+    const formattedKey = snakeCase(key).toUpperCase();
+    const newKey = `${prefix}_${formattedKey}`;
+    const newPath = [...originalPath, key];
+    if (typeof value === "object" && value !== null) {
+      Object.assign(acc, flattenObject(value, newKey, newPath));
+    } else {
+      acc[newKey] = { value, originalPath: newPath };
+    }
+    return acc;
+  }, {});
+}
+
+async function prepareConfigs(silgi = useSilgiCLI()) {
+  useCLIRuntimeConfig();
+  const _data = {
+    runtimeConfig: {}
+  };
+  for (const module of silgi.scanModules) {
+    if (module.meta.cliToRuntimeOptionsKeys && module.meta.cliToRuntimeOptionsKeys?.length > 0) {
+      for (const key of module.meta.cliToRuntimeOptionsKeys) {
+        _data[module.meta.configKey] = {
+          ..._data[module.meta.configKey],
+          [key]: module.options[key]
+        };
       }
-    );
-    silgi.schemas = scanFile.schemas || {};
-    silgi.services = scanFile.services || {};
-    silgi.shareds = scanFile.shareds || {};
-    silgi.routers = scanFile.routers || {};
-    return {
-      context,
-      object: {
-        schemas: scanFile.schemas,
-        services: scanFile.services,
-        shareds: scanFile.shareds
-      },
-      path
-    };
-  } catch (error) {
-    if (silgi.options.debug) {
-      console.error("Failed to read scan.ts file:", error);
     } else {
-      consola.withTag("silgi").error(error);
+      _data[module.meta.configKey] = {};
     }
-    return {
-      context,
-      object: {
-        schemas: {},
-        services: {},
-        shareds: {}
-      },
-      path
-    };
   }
+  await silgi.callHook("prepare:configs.ts", _data);
+  const importData = [
+    "import type { SilgiRuntimeOptions, SilgiRuntimeConfig, SilgiOptions } from 'silgi/types'",
+    "import { useRuntimeConfig } from 'silgi/runtime'",
+    "",
+    `export const runtimeConfig: SilgiRuntimeConfig = ${genObjectFromRawEntries(
+      Object.entries(_data.runtimeConfig).map(([key, value]) => [key, genEnsureSafeVar(value)]),
+      ""
+    )}`,
+    "",
+    "export const localConfig = useRuntimeConfig(undefined, runtimeConfig)",
+    ""
+  ];
+  delete _data.runtimeConfig;
+  importData.push(`export const cliConfigs: Partial<SilgiRuntimeOptions & SilgiOptions> = ${genObjectFromRawEntries(
+    Object.entries(_data).map(
+      ([key, value]) => [key, genEnsureSafeVar(value)]
+    )
+  )}`);
+  importData.unshift(...baseHeaderBannerComment);
+  await writeFile(
+    resolve(silgi.options.silgi.serverDir, "configs.ts"),
+    importData.join("\n")
+  );
 }
 
 async function prepareScanFile(silgi) {
@@ -1185,18 +1239,69 @@ async function prepareScanFile(silgi) {
   await silgi.callHook("after:scan.ts", importData);
   importData.unshift(...importsContent);
   importData.unshift(...baseHeaderBannerComment);
+  await writeFile(
+    resolve(silgi.options.silgi.serverDir, "scan.ts"),
+    importData.join("\n")
+  );
   return importData;
 }
 
-async function writeScanFiles(silgi) {
-  const data = await prepareScanFile(silgi);
-  if (!silgi.errors.length) {
-    await writeFile(
-      resolve(silgi.options.silgi.serverDir, "scan.ts"),
-      data.join("\n")
+async function readScanFile(silgi) {
+  const path = resolve(silgi.options.silgi.serverDir, "scan.ts");
+  const context = await promises.readFile(path, { encoding: "utf-8" });
+  silgi.unimport = createUnimport(silgi.options.imports || {});
+  await silgi.unimport.init();
+  const injectedResult = await silgi.unimport.injectImports(context, path);
+  if (!injectedResult) {
+    throw new Error("Failed to inject imports");
+  }
+  const jiti = createJiti(silgi.options.rootDir, {
+    fsCache: true,
+    moduleCache: false,
+    debug: silgi.options.debug === true,
+    alias: silgi.options.alias
+  });
+  try {
+    const scanFile = await jiti.evalModule(
+      injectedResult.code,
+      {
+        filename: path,
+        async: true,
+        conditions: silgi.options.conditions
+      },
+      async (data, name) => {
+        return (await silgi.unimport.injectImports(data, name)).code;
+      }
     );
+    silgi.schemas = scanFile.schemas || {};
+    silgi.services = scanFile.services || {};
+    silgi.shareds = scanFile.shareds || {};
+    silgi.routers = scanFile.routers || {};
+    return {
+      context,
+      object: {
+        schemas: scanFile.schemas,
+        services: scanFile.services,
+        shareds: scanFile.shareds
+      },
+      path
+    };
+  } catch (error) {
+    if (silgi.options.debug) {
+      console.error("Failed to read scan.ts file:", error);
+    } else {
+      consola.withTag("silgi").error(error);
+    }
+    return {
+      context,
+      object: {
+        schemas: {},
+        services: {},
+        shareds: {}
+      },
+      path
+    };
   }
-  await readScanFile(silgi);
 }
 
 async function createStorageCLI(silgi) {
@@ -1339,75 +1444,6 @@ async function compileTemplate(template, ctx) {
   throw new Error(`[nuxt] Invalid template. Templates must have either \`src\` or \`getContents\`: ${JSON.stringify(template)}`);
 }
 
-function useCLIRuntimeConfig(silgi) {
-  const safeRuntimeConfig = JSON.parse(JSON.stringify(silgi.options.runtimeConfig));
-  silgi.hook("prepare:configs.ts", (data) => {
-    data.runtimeConfig = safeRuntimeConfig;
-    silgi.options.envOptions = silgi.options.envOptions;
-  });
-  addTemplate({
-    filename: "env.example",
-    write: true,
-    where: ".silgi",
-    getContents() {
-      const flattenedConfig = flattenObject(safeRuntimeConfig);
-      const groupedVars = {};
-      Object.entries(flattenedConfig).forEach(([key, { value, originalPath }]) => {
-        const shouldExclude = silgi.options.codegen.env.safeList.some((safePath) => {
-          if (safePath.length !== originalPath.length)
-            return false;
-          return safePath.every((segment, index) => segment.toLowerCase() === originalPath[index].toLowerCase());
-        });
-        if (shouldExclude)
-          return;
-        if (originalPath.length > 0) {
-          const firstKey = originalPath[0];
-          const categoryName = extractCategoryFromCamel(firstKey);
-          if (!groupedVars[categoryName]) {
-            groupedVars[categoryName] = {};
-          }
-          groupedVars[categoryName][key] = value;
-        } else {
-          if (!groupedVars.OTHER) {
-            groupedVars.OTHER = {};
-          }
-          groupedVars.OTHER[key] = value;
-        }
-      });
-      return Object.entries(groupedVars).map(([category, vars]) => {
-        const varsContent = Object.entries(vars).map(([key, value]) => `${key}=${value}`).join("\n");
-        return `# ${category}
-${varsContent}`;
-      }).join("\n\n");
-    }
-  });
-  const _sharedRuntimeConfig = initRuntimeConfig(silgi.options.envOptions, silgi.options.runtimeConfig);
-  silgi.options.runtimeConfig = safeRuntimeConfig;
-  return _sharedRuntimeConfig;
-}
-function extractCategoryFromCamel(str) {
-  if (/^[a-z]+[A-Z]/.test(str)) {
-    const matches = str.match(/^([a-z]+)([A-Z][a-z0-9]*)?/);
-    if (matches && matches[2]) {
-      return `${matches[1].toUpperCase()}_${matches[2].toUpperCase()}`;
-    }
-  }
-  return str.toUpperCase();
-}
-function flattenObject(obj, prefix = "SILGI", originalPath = []) {
-  return Object.entries(obj).reduce((acc, [key, value]) => {
-    const formattedKey = snakeCase(key).toUpperCase();
-    const newKey = `${prefix}_${formattedKey}`;
-    const newPath = [...originalPath, key];
-    if (typeof value === "object" && value !== null) {
-      Object.assign(acc, flattenObject(value, newKey, newPath));
-    } else {
-      acc[newKey] = { value, originalPath: newPath };
-    }
-    return acc;
-  }, {});
-}
-
 const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
 async function scanAndSyncOptions(silgi) {
   const scannedModules = await scanModules(silgi);
@@ -1467,10 +1503,9 @@ async function createSilgiCLI(config = {}, opts = {}) {
     addHooks: hooks.addHooks,
     hook: hooks.hook,
     adapters: {},
-    useLocalConfig: () => useRuntimeConfig(void 0, options.runtimeConfig, true),
+    useLocalConfig: () => useRuntimeConfig(void 0, options.runtimeConfig),
     meta: {}
   };
-  sharedRuntimeConfig(silgi.options.runtimeConfig);
   if (silgiCLICtx.tryUse()) {
     silgiCLICtx.unset();
     silgiCLICtx.set(silgi);
@@ -1478,7 +1513,6 @@ async function createSilgiCLI(config = {}, opts = {}) {
     silgiCLICtx.set(silgi);
     silgi.hook("close", () => silgiCLICtx.unset());
   }
-  await silgi.hooks.callHook("ready", silgi);
   if (silgi.options.debug) {
     createDebugger(silgi.hooks, { tag: "silgi" });
     silgi.options.plugins.push({
@@ -1486,25 +1520,28 @@ async function createSilgiCLI(config = {}, opts = {}) {
       packageImport: "silgi/runtime/internal/debug"
     });
   }
+  await scanAndSyncOptions(silgi);
+  await scanSilgiExports();
+  await scanModules$1(silgi);
+  await installModules(silgi, true);
+  await prepareConfigs();
+  sharedRuntimeConfig(silgi.options.runtimeConfig, silgi.options.dev);
   if (silgi.options.adapters && Object.keys(silgi.options.adapters)?.length > 0) {
     for (const [key, value] of Object.entries(silgi.options.adapters)) {
       if (typeof value === "function") {
-        const resolved = value();
+        const resolved = value(silgi);
         silgi.adapters[key] = resolved instanceof Promise ? await resolved : resolved;
       } else {
         silgi.adapters[key] = value;
       }
     }
   }
-  await scanAndSyncOptions(silgi);
-  await scanModules$1(silgi);
-  await scanSilgiExports();
-  await installModules(silgi, true);
-  useCLIRuntimeConfig(silgi);
+  await prepareScanFile(silgi);
+  await readScanFile(silgi);
+  await installModules(silgi);
   for (const framework of frameworkSetup) {
     await framework(silgi);
   }
-  await writeScanFiles(silgi);
   silgi.storage = await createStorageCLI(silgi);
   silgi.hooks.hook("close", async () => {
     await silgi.storage.dispose();
@@ -1513,8 +1550,6 @@ async function createSilgiCLI(config = {}, opts = {}) {
     silgi.logger.level = silgi.options.logLevel;
   }
   silgi.hooks.addHooks(silgi.options.hooks);
-  await installModules(silgi);
-  await silgi.hooks.callHook("scanFiles:done", silgi);
   await generateApp(silgi);
   if (silgi.options.imports) {
     silgi.options.imports.dirs ??= [];
@@ -1540,15 +1575,14 @@ async function createSilgiCLI(config = {}, opts = {}) {
     await silgi.unimport.init();
   }
   await registerModuleExportScan(silgi);
-  await writeScanFiles(silgi);
-  sharedRuntimeConfig(silgi.options.runtimeConfig);
+  await silgi.hooks.callHook("ready", silgi);
   return silgi;
 }
 
 async function generateApiFul(silgi) {
   const config = silgi.options.apiFul;
   if (!hasSilgiModule("openapi")) {
-    silgi.logger.info("Silgi OpenAPI module not found, if you want to use it, please install it @silgi/openapi");
+    silgi.options.dev || silgi.logger.info("Silgi OpenAPI module not found, if you want to use it, please install it @silgi/openapi");
     return;
   }
   if (!config.services || hasSilgiModule("openapi")) {
@@ -1583,9 +1617,6 @@ async function generateApiFul(silgi) {
   });
 }
 
-async function prepare(_silgi) {
-}
-
 function debugMode(name) {
   const silgi = useSilgiCLI$1();
   if (silgi.options.debug === true || typeof silgi.options.debug === "object" && silgi.options.debug[name]) {
@@ -1636,45 +1667,6 @@ async function prepareCommands(silgi = useSilgiCLI$1()) {
   silgi.options.commands = commands;
 }
 
-async function prepareConfigs(silgi) {
-  const _data = {
-    runtimeConfig: {}
-  };
-  for (const module of silgi.scanModules) {
-    if (module.meta.cliToRuntimeOptionsKeys && module.meta.cliToRuntimeOptionsKeys?.length > 0) {
-      for (const key of module.meta.cliToRuntimeOptionsKeys) {
-        _data[module.meta.configKey] = {
-          ..._data[module.meta.configKey],
-          [key]: module.options[key]
-        };
-      }
-    } else {
-      _data[module.meta.configKey] = {};
-    }
-  }
-  await silgi.callHook("prepare:configs.ts", _data);
-  const importData = [
-    "import type { SilgiRuntimeOptions, SilgiRuntimeConfig, SilgiOptions } from 'silgi/types'",
-    "import { useRuntimeConfig } from 'silgi/runtime'",
-    "",
-    `export const runtimeConfig: SilgiRuntimeConfig = ${genObjectFromRawEntries(
-      Object.entries(_data.runtimeConfig).map(([key, value]) => [key, genEnsureSafeVar(value)]),
-      ""
-    )}`,
-    "",
-    "export const localConfig = useRuntimeConfig(undefined, runtimeConfig)",
-    ""
-  ];
-  delete _data.runtimeConfig;
-  importData.push(`export const cliConfigs: Partial<SilgiRuntimeOptions & SilgiOptions> = ${genObjectFromRawEntries(
-    Object.entries(_data).map(
-      ([key, value]) => [key, genEnsureSafeVar(value)]
-    )
-  )}`);
-  importData.unshift(...baseHeaderBannerComment);
-  return importData;
-}
-
 async function prepareCoreFile(silgi) {
   const { genImports, genTypeImports, addImportItem, addImportItemType } = addImports({
     imports: [
@@ -1834,17 +1826,12 @@ async function prepareCoreFile(silgi) {
 
 async function writeCoreFile(silgi) {
   const coreContent = await prepareCoreFile(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")
-  });
   buildFiles.push({
     path: join(silgiDir, "meta.ts"),
     contents: `export const meta = ${JSON.stringify(silgi.meta, null, 2)}`
@@ -2089,7 +2076,6 @@ async function writeTypesAndFiles(silgi) {
 }
 
 async function build(silgi) {
-  await prepare();
   await generateApiFul(silgi);
   await prepareCommands(silgi);
   await writeCoreFile(silgi);

package/dist/cli/dev.mjs

@@ -21,15 +21,16 @@ async function prepareBuild(config) {
 }
 
 async function watchDev() {
+  const silgi = useSilgiCLI$1();
   let watcher;
   async function load() {
     await prepareBuild({
       commandType: "prepare",
-      activeEnvironment: ".env"
+      activeEnvironment: silgi.options.activeEnvironment || ".env",
+      dev: true
     });
   }
   const reload = debounce(load);
-  const silgi = useSilgiCLI$1();
   silgi.options.watchOptions.ignored ??= [];
   silgi.options.watchOptions.ignoreInitial = true;
   if (Array.isArray(silgi.options.watchOptions.ignored)) {

package/dist/cli/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
 
-const version = "0.39.15";
+const version = "0.40.0";
 const packageJson = {
 	version: version};
 
@@ -20,10 +20,11 @@ const main = defineCommand({
   subCommands: {
     prepare: () => import('./prepare.mjs').then(function (n) { return n.p; }).then((m) => m.default),
     init: () => import('./init.mjs').then((m) => m.default),
-    run: () => import('./prepare.mjs').then(function (n) { return n.r; }).then((m) => m.default),
+    commands: () => import('./prepare.mjs').then(function (n) { return n.b; }).then((m) => m.default),
     install: () => import('./install.mjs').then((m) => m.default),
     watch: () => import('./watch.mjs').then((m) => m.default),
-    reset: () => import('./reset.mjs').then((m) => m.default)
+    reset: () => import('./reset.mjs').then((m) => m.default),
+    run: () => import('./run.mjs').then((m) => m.default)
   },
   run() {
   }

package/dist/cli/init.mjs

@@ -26,9 +26,9 @@ import 'ufo';
 import 'oxc-parser';
 import 'tinyglobby';
 import 'ignore';
+import 'scule';
 import 'klona';
 import 'unstorage';
-import 'scule';
 import './loader.mjs';
 import 'c12';
 import 'compatx';

package/dist/cli/install.mjs

@@ -30,9 +30,9 @@ import 'node:fs/promises';
 import 'oxc-parser';
 import 'tinyglobby';
 import 'ignore';
+import 'scule';
 import 'klona';
 import 'unstorage';
-import 'scule';
 import './loader.mjs';
 import 'c12';
 import 'compatx';

package/dist/cli/prepare.mjs

@@ -51,7 +51,7 @@ const command$1 = defineCommand({
   async run({ args }) {
     if (args.prepare) {
       await runCommand(command, {
-        rawArgs: ["--commandType", "run"]
+        rawArgs: ["--commandType", "commands"]
       });
     }
     const silgi = useSilgiCLI();
@@ -121,7 +121,7 @@ const command$1 = defineCommand({
   }
 });
 
-const run = {
+const commands = {
   __proto__: null,
   default: command$1
 };
@@ -166,7 +166,7 @@ const command = defineCommand({
       activeEnvironment: args.env
     });
     await build(silgi);
-    if (args.commandType !== "run") {
+    if (args.commandType !== "commands") {
       await runCommand(command$1, {
         rawArgs: ["--tag", "init", "--prepare", "false"]
       });
@@ -179,4 +179,4 @@ const prepare = {
   default: command
 };
 
-export { command as a, cancelOnCancel as c, prepare as p, run as r };
+export { command as a, commands as b, cancelOnCancel as c, prepare as p };

package/dist/cli/run.mjs

@@ -0,0 +1,157 @@
+import { defineCommand, runCommand } from 'citty';
+import consola from 'consola';
+import { useSilgiCLI } from 'silgi';
+import { version } from 'silgi/meta';
+import { x } from 'tinyexec';
+import { w as watchDev } from './dev.mjs';
+import { c as commonArgs } from './common.mjs';
+import { a as command$1 } from './prepare.mjs';
+import 'chokidar';
+import 'pathe';
+import 'perfect-debounce';
+import '../_chunks/silgiApp.mjs';
+import 'unctx';
+import './build.mjs';
+import 'hookable';
+import 'silgi/kit';
+import 'silgi/runtime';
+import 'silgi/runtime/meta';
+import 'unimport';
+import '@clack/prompts';
+import 'node:fs';
+import 'dotenv';
+import 'knitwork';
+import 'mlly';
+import 'dev-jiti';
+import './compatibility.mjs';
+import 'semver/functions/satisfies.js';
+import 'node:url';
+import 'defu';
+import 'exsolve';
+import 'ufo';
+import 'node:fs/promises';
+import 'oxc-parser';
+import 'tinyglobby';
+import 'ignore';
+import 'scule';
+import 'klona';
+import 'unstorage';
+import './loader.mjs';
+import 'c12';
+import 'compatx';
+import 'klona/full';
+import 'std-env';
+import 'consola/utils';
+import 'escape-string-regexp';
+import 'pkg-types';
+import 'apiful/openapi';
+import 'pathe/utils';
+import 'untyped';
+import './types.mjs';
+import 'node:child_process';
+
+const command = defineCommand({
+  meta: {
+    name: "dev",
+    description: "Start the development server for the project",
+    version: version
+  },
+  args: {
+    ...commonArgs,
+    command: {
+      type: "string",
+      description: "your application start command",
+      required: false
+    }
+  },
+  async run({ args, rawArgs }) {
+    await runCommand(command$1, {
+      rawArgs: ["--commandType", "dev", "--dev", "true"]
+    });
+    const silgi = useSilgiCLI();
+    const startCommand = args.command || rawArgs[0];
+    let childPid = null;
+    let hasExited = false;
+    let exitTimeout = null;
+    const cleanupAndExit = (code = 0) => {
+      if (hasExited)
+        return;
+      hasExited = true;
+      if (exitTimeout)
+        clearTimeout(exitTimeout);
+      process.exit(code);
+    };
+    const handleSignal = async (signal, watcher) => {
+      consola.info(`Received ${signal}, terminating process...`);
+      if (watcher && typeof watcher.close === "function") {
+        try {
+          await watcher.close();
+        } catch {
+        }
+      }
+      if (childPid) {
+        try {
+          process.kill(childPid, signal);
+        } catch (err) {
+          consola.error(`Failed to kill process: ${err instanceof Error ? err.message : err}`);
+        }
+        exitTimeout = setTimeout(() => {
+          consola.warn("Process did not exit gracefully, forcing termination...");
+          try {
+            if (childPid)
+              process.kill(childPid, "SIGKILL");
+          } catch {
+          }
+          cleanupAndExit(1);
+        }, 3e3);
+      } else {
+        cleanupAndExit(0);
+      }
+    };
+    const setupSignalHandlers = (watcher) => {
+      ["SIGINT", "SIGTERM", "SIGHUP"].forEach((signal) => {
+        process.on(signal, () => {
+          handleSignal(signal, watcher);
+        });
+      });
+    };
+    try {
+      const watcher = await watchDev();
+      setupSignalHandlers(watcher);
+      consola.info(`Starting command: nr ${startCommand}`);
+      const proc = x(
+        "nr",
+        [startCommand],
+        {
+          nodeOptions: {
+            stdio: "inherit",
+            shell: true,
+            cwd: process.cwd(),
+            killSignal: "SIGINT"
+          }
+        }
+      );
+      if (proc && typeof proc.pid === "number") {
+        childPid = proc.pid;
+      }
+      try {
+        await proc;
+        consola.success(`Process exited successfully.`);
+        cleanupAndExit(0);
+      } catch (procError) {
+        const exitCode = procError && typeof procError.exitCode === "number" ? procError.exitCode : 1;
+        consola.error(`Process exited with code: ${exitCode}`);
+        if (silgi.options.debug)
+          consola.withTag("silgi").error("Error while running the command", procError);
+        cleanupAndExit(exitCode);
+      }
+    } catch (error) {
+      consola.error(`Failed to start the development server: ${error instanceof Error ? error.message : error}`);
+      if (silgi.options.debug)
+        consola.withTag("silgi").error("Error while running the command", error);
+      cleanupAndExit(1);
+    }
+  }
+});
+
+export { command as default };

package/dist/cli/watch.mjs

@@ -32,9 +32,9 @@ import 'node:fs/promises';
 import 'oxc-parser';
 import 'tinyglobby';
 import 'ignore';
+import 'scule';
 import 'klona';
 import 'unstorage';
-import 'scule';
 import './loader.mjs';
 import 'c12';
 import 'compatx';

package/dist/core/index.mjs

@@ -369,11 +369,11 @@ async function createSilgi(config) {
     silgiCtx.set(silgi);
     silgi.hook("close", () => silgiCtx.unset());
   }
-  silgi.logger.info("Silgi installed");
   hooks.hookOnce("close", async () => {
     hooks.removeAllHooks();
     await silgi.storage.dispose();
   });
+  silgi.logger.info("Silgi Start");
   return silgi;
 }
 

package/dist/types/index.d.mts

@@ -922,7 +922,6 @@ interface SilgiCLIHooks extends SilgiHooks {
      * @returns Promise
      */
     'app:templatesGenerated': (app: SilgiCLI, templates: ResolvedSilgiTemplate[], options?: GenerateAppOptions) => HookResult;
-    'scanFiles:done': (app: SilgiCLI) => HookResult;
     'prepare:commands': (commands: Commands[]) => HookResult;
     'nextjs:prepare': (data: {
         config: NextConfig;
@@ -1207,7 +1206,7 @@ interface SilgiCLIOptions extends PresetOptions {
     ignoreOptions: Options;
     installPackages: Record<'dependencies' | 'devDependencies', Record<string, string>>;
     apiFul: ApifulConfig;
-    adapters: Record<string, Adapter<Record<string, any>, TablesSchema, InferModelTypes<TablesSchema>> | (() => Adapter<Record<string, any>, TablesSchema, InferModelTypes<TablesSchema>>) | (() => Promise<Adapter<Record<string, any>, TablesSchema, InferModelTypes<TablesSchema>>>)>;
+    adapters: Record<string, Adapter<Record<string, any>, TablesSchema, InferModelTypes<TablesSchema>> | ((silgi: SilgiCLI) => Adapter<Record<string, any>, TablesSchema, InferModelTypes<TablesSchema>>) | ((silgi: SilgiCLI) => Promise<Adapter<Record<string, any>, TablesSchema, InferModelTypes<TablesSchema>>>)>;
 }
 /**
  * Silgi input config (silgi.config)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.39.15",
+  "version": "0.40.0",
   "private": false,
   "sideEffects": false,
   "exports": {
@@ -95,6 +95,7 @@
     }
   },
   "dependencies": {
+    "@antfu/ni": "^24.3.0",
     "@clack/prompts": "^0.10.1",
     "@fastify/deepmerge": "^3.1.0",
     "@standard-community/standard-json": "^0.2.0",
@@ -131,6 +132,7 @@
     "semver": "^7.7.1",
     "srvx": "^0.6.0",
     "std-env": "^3.9.0",
+    "tinyexec": "^1.0.1",
     "tinyglobby": "^0.2.13",
     "ufo": "^1.6.1",
     "unadapter": "^0.1.2",