silgi 0.24.15 → 0.24.17

package/dist/cli/build/prepare.mjs

@@ -0,0 +1,43 @@
+import { genObjectFromRawEntries, genObjectFromRaw, genObjectFromValues } from 'knitwork';
+import { join } from 'pathe';
+import { writeFile } from 'silgi/kit';
+
+async function prepareBuild(silgi) {
+  try {
+    if (!silgi?.routeRules?.exportRules) {
+      throw new Error("Invalid silgi configuration: routeRules or exportRules is undefined");
+    }
+    const exportedRules = silgi.routeRules.exportRules();
+    if (!exportedRules || typeof exportedRules !== "object") {
+      throw new Error("No valid route rules to export");
+    }
+    const content = `/* eslint-disable */
+// @ts-nocheck
+// This file is auto-generated at build time by Silgi
+// Contains route rules with preserved functions
+// DO NOT MODIFY THIS FILE DIRECTLY
+
+export const routeRules = ${genObjectFromRawEntries(
+      Object.entries(exportedRules).map(([key, value]) => {
+        if (typeof value === "function") {
+          return [key, genObjectFromRaw(value)];
+        }
+        return [key, genObjectFromValues(value)];
+      })
+    )}
+`;
+    const serverDir = silgi.options.silgi.serverDir;
+    if (!serverDir) {
+      throw new Error("Server directory not defined in configuration");
+    }
+    const file = join(serverDir, "rules.ts");
+    if (!silgi.errors.length) {
+      await writeFile(file, content);
+    }
+  } catch (error) {
+    console.error("\u274C Failed to prepare build:", error instanceof Error ? error.message : String(error));
+    throw error;
+  }
+}
+
+export { prepareBuild };

package/dist/cli/{dev.mjs → commands/dev.mjs}

@@ -5,49 +5,10 @@ import consola from 'consola';
 import { join } from 'pathe';
 import { useSilgiCLI } from 'silgi';
 import { version } from 'silgi/meta';
-import { s as silgiCLIIClose } from '../_chunks/silgiApp.mjs';
-import { c as commonArgs, p as prepare } from './prepare.mjs';
-import 'knitwork';
-import 'silgi/kit';
-import 'node:fs';
-import 'node:fs/promises';
-import 'hookable';
-import 'silgi/runtime/meta';
-import 'unimport';
-import 'ufo';
-import '@clack/prompts';
-import 'dotenv';
-import 'mlly';
-import 'dev-jiti';
-import './compatibility.mjs';
-import 'semver/functions/satisfies.js';
-import 'node:url';
-import 'defu';
-import 'exsolve';
-import 'untyped';
-import 'globby';
-import 'ignore';
-import '@oxc-parser/wasm';
-import 'klona';
-import 'silgi/runtime';
-import 'unstorage';
-import './types.mjs';
-import 'c12';
-import 'compatx';
-import 'klona/full';
-import 'std-env';
-import 'consola/utils';
-import 'escape-string-regexp';
-import 'pkg-types';
-import 'pathe/utils';
-import 'unctx';
-import 'node:child_process';
-import 'picocolors';
-
-async function reloadScan(path, _stats) {
-  const silgi = useSilgiCLI();
-  await silgi.callHook("reload:scan", path, _stats);
-}
+import { silgiCLIIClose } from '../../core/silgiApp.mjs';
+import { reloadScan } from '../core/devServer.mjs';
+import { commonArgs } from '../utils/common.mjs';
+import prepare from './prepare.mjs';
 
 const dev = defineCommand({
   meta: {

package/dist/cli/commands/env.mjs

@@ -0,0 +1,40 @@
+import * as p from '@clack/prompts';
+import { setupDotenv } from '../core/env.mjs';
+
+let initialized = false;
+async function prepareEnv(silgiConfig) {
+  if (initialized)
+    return;
+  initialized = true;
+  const customEnvironments = silgiConfig.environments;
+  const environment = silgiConfig.activeEnvironment ? silgiConfig.activeEnvironment : await p.select({
+    message: "Select an environment",
+    options: customEnvironments?.length > 0 ? customEnvironments.map((env) => ({
+      label: env.fileName,
+      value: env.fileName
+    })) : [
+      { label: "Development (.env.dev)", value: "dev" },
+      { label: "Docker (.env.docker)", value: "docker" },
+      { label: "Staging (.env.staging)", value: "staging" },
+      { label: "Testing (.env.testing)", value: "testing" },
+      { label: "Production (.env)", value: ".env" }
+    ]
+  });
+  const findEnv = customEnvironments?.find((env) => env.fileName === environment);
+  if (findEnv) {
+    await setupDotenv({
+      cwd: findEnv.cwd || silgiConfig.rootDir,
+      interpolate: findEnv.interpolate,
+      fileName: findEnv.fileName,
+      env: findEnv.env
+    });
+  } else {
+    await setupDotenv({
+      cwd: silgiConfig.rootDir,
+      interpolate: true,
+      fileName: environment === ".env" ? ".env" : `.env.${environment}`
+    });
+  }
+}
+
+export { prepareEnv };

package/dist/cli/{install.mjs → commands/install.mjs}

@@ -4,43 +4,9 @@ import { defineCommand, runCommand } from 'citty';
 import { consola } from 'consola';
 import { resolve } from 'pathe';
 import { version } from 'silgi/meta';
-import { c as commonArgs, p as prepare } from './prepare.mjs';
-import { l as loadOptions } from './types.mjs';
-import '../_chunks/silgiApp.mjs';
-import 'knitwork';
-import 'silgi/kit';
-import 'node:fs/promises';
-import 'hookable';
-import 'silgi';
-import 'silgi/runtime/meta';
-import 'unimport';
-import 'ufo';
-import '@clack/prompts';
-import 'dotenv';
-import 'mlly';
-import 'dev-jiti';
-import './compatibility.mjs';
-import 'semver/functions/satisfies.js';
-import 'node:url';
-import 'defu';
-import 'exsolve';
-import 'untyped';
-import 'globby';
-import 'ignore';
-import '@oxc-parser/wasm';
-import 'klona';
-import 'silgi/runtime';
-import 'unstorage';
-import 'pathe/utils';
-import 'unctx';
-import 'picocolors';
-import 'c12';
-import 'compatx';
-import 'klona/full';
-import 'std-env';
-import 'consola/utils';
-import 'escape-string-regexp';
-import 'pkg-types';
+import { commonArgs } from '../utils/common.mjs';
+import prepare from './prepare.mjs';
+import { loadOptions } from '../config/loader.mjs';
 
 const install = defineCommand({
   meta: {

package/dist/cli/commands/prepare.mjs

@@ -0,0 +1,66 @@
+import { defineCommand, runCommand } from 'citty';
+import { resolve } from 'pathe';
+import { version } from 'silgi/meta';
+import { prepareBuild } from '../build/prepare.mjs';
+import { prepare as prepare$1 } from '../core/prepare.mjs';
+import { createSilgiCLI } from '../core/silgi.mjs';
+import { writeCoreFile } from '../scan/writeCoreFile.mjs';
+import { writeTypesAndFiles } from '../scan/writeTypesAndFiles.mjs';
+import { commonArgs } from '../utils/common.mjs';
+import run from './run.mjs';
+
+const prepare = defineCommand({
+  meta: {
+    name: "prepare",
+    description: "Generate types for the project",
+    version: version
+  },
+  args: {
+    ...commonArgs,
+    preset: {
+      type: "string",
+      description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
+    },
+    stub: {
+      type: "boolean",
+      description: "Run in silgi development mode"
+    },
+    dev: {
+      type: "boolean",
+      description: "Run in silgi development mode"
+    },
+    env: {
+      type: "string",
+      description: "The environment to use"
+    },
+    commands: {
+      type: "string",
+      description: "The commands to run"
+    }
+  },
+  async run({ args }) {
+    const rootDir = resolve(args.dir || args._dir || ".");
+    const silgi = await createSilgiCLI({
+      rootDir,
+      dev: args.dev || args.stub,
+      stub: args.stub,
+      preset: args.preset,
+      commandType: "prepare",
+      activeEnvironment: args.env
+    });
+    await prepare$1();
+    await writeTypesAndFiles(silgi);
+    await writeCoreFile(silgi);
+    await prepareBuild(silgi);
+    if (!args.commands) {
+      await runCommand(run, {
+        rawArgs: ["--tag", "init", "--active", "false"]
+      });
+    }
+    return {
+      silgi
+    };
+  }
+});
+
+export { prepare as default };

package/dist/cli/{prepare.mjs → commands/run.mjs}

@@ -1,27 +1,18 @@
-import { defineCommand, runCommand } from 'citty';
-import { resolve } from 'pathe';
-import { version } from 'silgi/meta';
-import { p as prepareEnv, s as silgiCLIIClose, c as createSilgiCLI, a as prepare$2, w as writeTypesAndFiles, b as writeCoreFile, d as prepareBuild } from '../_chunks/silgiApp.mjs';
 import { execSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import * as p from '@clack/prompts';
+import { defineCommand, runCommand } from 'citty';
 import { consola } from 'consola';
 import { createJiti } from 'dev-jiti';
+import { resolve } from 'pathe';
 import color from 'picocolors';
 import { useSilgiCLI } from 'silgi';
-import { l as loadOptions } from './types.mjs';
-
-const commonArgs = {
-  dir: {
-    type: "string",
-    description: "project root directory"
-  },
-  _dir: {
-    type: "positional",
-    default: ".",
-    description: "project root directory (prefer using `--dir`)"
-  }
-};
+import { version } from 'silgi/meta';
+import { silgiCLIIClose } from '../../core/silgiApp.mjs';
+import { commonArgs } from '../utils/common.mjs';
+import { prepareEnv } from './env.mjs';
+import prepare from './prepare.mjs';
+import { loadOptions } from '../config/loader.mjs';
 
 const run = defineCommand({
   meta: {
@@ -181,68 +172,4 @@ const run = defineCommand({
   }
 });
 
-const run$1 = {
-  __proto__: null,
-  default: run
-};
-
-const prepare = defineCommand({
-  meta: {
-    name: "prepare",
-    description: "Generate types for the project",
-    version: version
-  },
-  args: {
-    ...commonArgs,
-    preset: {
-      type: "string",
-      description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
-    },
-    stub: {
-      type: "boolean",
-      description: "Run in silgi development mode"
-    },
-    dev: {
-      type: "boolean",
-      description: "Run in silgi development mode"
-    },
-    env: {
-      type: "string",
-      description: "The environment to use"
-    },
-    commands: {
-      type: "string",
-      description: "The commands to run"
-    }
-  },
-  async run({ args }) {
-    const rootDir = resolve(args.dir || args._dir || ".");
-    const silgi = await createSilgiCLI({
-      rootDir,
-      dev: args.dev || args.stub,
-      stub: args.stub,
-      preset: args.preset,
-      commandType: "prepare",
-      activeEnvironment: args.env
-    });
-    await prepare$2();
-    await writeTypesAndFiles(silgi);
-    await writeCoreFile(silgi);
-    await prepareBuild(silgi);
-    if (!args.commands) {
-      await runCommand(run, {
-        rawArgs: ["--tag", "init", "--active", "false"]
-      });
-    }
-    return {
-      silgi
-    };
-  }
-});
-
-const prepare$1 = {
-  __proto__: null,
-  default: prepare
-};
-
-export { prepare$1 as a, commonArgs as c, prepare as p, run$1 as r };
+export { run as default };

package/dist/cli/config/defaults.mjs

@@ -0,0 +1,129 @@
+import { isDebug, isTest } from 'std-env';
+
+const SilgiCLIDefaults = {
+  // General
+  debug: isDebug,
+  // timing: isDebug,
+  logLevel: isTest ? 1 : 3,
+  // runtimeConfig: { app: {}, silgi: {} },
+  appConfig: {},
+  appConfigFiles: [],
+  commandType: "prepare",
+  runtimeConfig: {
+    silgi: {
+      version: "0.0.1"
+    }
+  },
+  serviceParseModules: [],
+  storages: [],
+  devServer: {
+    watch: []
+  },
+  // Dirs
+  scanDirs: [],
+  build: {
+    dir: ".silgi",
+    typesDir: "{{ build.dir }}/types",
+    templates: []
+  },
+  output: {
+    dir: "{{ rootDir }}/.output",
+    serverDir: "{{ output.dir }}/server",
+    publicDir: "{{ output.dir }}/public"
+  },
+  serverDir: "{{ rootDir }}/server",
+  clientDir: "{{ rootDir }}/client",
+  silgi: {
+    serverDir: "{{ serverDir }}/silgi",
+    clientDir: "{{ clientDir }}/silgi",
+    publicDir: "{{ silgi.serverDir }}/public",
+    utilsDir: "{{ silgi.serverDir }}/utils",
+    vfsDir: "{{ silgi.serverDir }}/vfs",
+    typesDir: "{{ silgi.serverDir }}/types"
+  },
+  // Modules
+  _modules: [],
+  modules: [],
+  routeRules: {},
+  // Features
+  // experimental: {},
+  future: {},
+  storage: {},
+  devStorage: {},
+  stub: false,
+  // bundledStorage: [],
+  // publicAssets: [],
+  // serverAssets: [],
+  plugins: [],
+  // tasks: {},
+  // scheduledTasks: {},
+  imports: {
+    exclude: [],
+    dirs: [],
+    presets: [],
+    virtualImports: ["#silgiImports"]
+  },
+  // virtual: {},
+  // compressPublicAssets: false,
+  ignore: [],
+  // Dev
+  dev: false,
+  // devServer: { watch: [] },
+  watchOptions: {
+    ignoreInitial: true,
+    ignored: [
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/.silgi/**",
+      "**/.output/**",
+      "**/.vscode/**",
+      "**/.idea/**",
+      "**/.nuxt/**",
+      "**/.next/**",
+      "**/.gitignore",
+      "**/.gitattributes",
+      "**/assets/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/coverage/**",
+      "**/test/**",
+      "**/tests/**",
+      "**/tmp/**"
+    ]
+  },
+  // devProxy: {},
+  // Logging
+  // logging: {
+  //   compressedSizes: true,
+  //   buildSuccess: true,
+  // },
+  // Routing
+  // baseURL: process.env.NITRO_APP_BASE_URL || '/',
+  // handlers: [],
+  // devHandlers: [],
+  // errorHandler: undefined,
+  // Advanced
+  typescript: {
+    strict: false,
+    generateTsConfig: true,
+    // generateRuntimeConfigTypes: true,
+    tsconfigPath: ".silgi/types/silgi.tsconfig.json",
+    tsConfig: {},
+    customConditions: [],
+    generateRuntimeConfigTypes: true,
+    removeFileExtension: false
+  },
+  conditions: [],
+  nodeModulesDirs: [],
+  // hooks: {},
+  commands: {},
+  // Framework
+  framework: {
+    name: "h3",
+    version: ""
+  },
+  extensions: [".js", ".jsx", ".mjs", ".ts", ".tsx", ".vue"],
+  ignoreOptions: void 0
+};
+
+export { SilgiCLIDefaults };

package/dist/cli/config/index.mjs

@@ -1,16 +1,2 @@
-export { l as loadOptions, s as silgiGenerateType } from '../types.mjs';
-import 'c12';
-import 'compatx';
-import 'klona/full';
-import 'std-env';
-import 'consola';
-import 'consola/utils';
-import 'pathe';
-import 'escape-string-regexp';
-import 'mlly';
-import 'node:fs';
-import 'pkg-types';
-import 'silgi/kit';
-import 'silgi/runtime/meta';
-import 'ufo';
-import 'defu';
+export { loadOptions } from './loader.mjs';
+export { silgiGenerateType } from './types.mjs';

package/dist/cli/config/loader.mjs

@@ -0,0 +1,97 @@
+import { watchConfig, loadConfig } from 'c12';
+import { resolveCompatibilityDates } from 'compatx';
+import { klona } from 'klona/full';
+import { SilgiCLIDefaults } from './defaults.mjs';
+import { resolveCompatibilityOptions, fallbackCompatibilityDate } from './resolvers/compatibility.mjs';
+import { resolveImportsOptions } from './resolvers/imports.mjs';
+import { resolvePathOptions } from './resolvers/paths.mjs';
+import { resolveStorageOptions } from './resolvers/storage.mjs';
+import { resolveURLOptions } from './resolvers/url.mjs';
+
+const configResolvers = [
+  resolveCompatibilityOptions,
+  resolvePathOptions,
+  resolveImportsOptions,
+  // resolveRouteRulesOptions,
+  // resolveDatabaseOptions,
+  // resolveFetchOptions,
+  // resolveExportConditionsOptions,
+  // resolveRuntimeConfigOptions,
+  // resolveOpenAPIOptions,
+  resolveURLOptions,
+  // resolveAssetsOptions,
+  resolveStorageOptions
+  // resolveErrorOptions,
+];
+async function loadOptions(configOverrides = {}, opts = {}) {
+  const options = await _loadUserConfig(configOverrides, opts);
+  for (const resolver of configResolvers) {
+    await resolver(options);
+  }
+  return options;
+}
+async function _loadUserConfig(configOverrides = {}, opts = {}) {
+  const presetOverride = configOverrides.preset || process.env.SILGI_PRESET;
+  if (configOverrides.dev) ;
+  configOverrides = klona(configOverrides);
+  globalThis.defineSilgiConfig = globalThis.defineSilgiConfig || ((c) => c);
+  let compatibilityDate = configOverrides.compatibilityDate || opts.compatibilityDate || (process.env.SILGI_COMPATIBILITY_DATE || process.env.SERVER_COMPATIBILITY_DATE || process.env.COMPATIBILITY_DATE);
+  const { resolvePreset } = await import('silgi/presets');
+  const loadedConfig = await (opts.watch ? watchConfig : loadConfig)({
+    name: "silgi",
+    cwd: configOverrides.rootDir,
+    dotenv: configOverrides.dev,
+    extend: { extendKey: ["extends", "preset"] },
+    overrides: {
+      ...configOverrides,
+      preset: presetOverride
+    },
+    async defaultConfig({ configs }) {
+      const getConf = (key) => configs.main?.[key] ?? configs.rc?.[key] ?? configs.packageJson?.[key];
+      if (!compatibilityDate) {
+        compatibilityDate = getConf("compatibilityDate");
+      }
+      return {
+        // typescript: {
+        //   generateRuntimeConfigTypes:
+        //     !framework?.name || framework.name === 'nitro',
+        // },
+        preset: presetOverride || (await resolvePreset("", {
+          static: getConf("static"),
+          compatibilityDate: compatibilityDate || fallbackCompatibilityDate
+        }))?._meta?.name
+      };
+    },
+    defaults: SilgiCLIDefaults,
+    jitiOptions: {
+      alias: {
+        "silgi/config": "silgi/config"
+      }
+    },
+    async resolve(id) {
+      const preset = await resolvePreset(id, {
+        static: configOverrides.static,
+        compatibilityDate: compatibilityDate || fallbackCompatibilityDate
+      });
+      if (preset) {
+        return {
+          config: klona(preset)
+        };
+      }
+    },
+    ...opts.c12
+  });
+  delete globalThis.defineSilgiConfig;
+  const options = klona(loadedConfig.config);
+  options._config = configOverrides;
+  options._c12 = loadedConfig;
+  const _presetName = (loadedConfig.layers || []).find((l) => l.config?._meta?.name)?.config?._meta?.name || presetOverride;
+  options.preset = _presetName;
+  options.compatibilityDate = resolveCompatibilityDates(
+    compatibilityDate,
+    options.compatibilityDate
+  );
+  return options;
+}
+
+export { loadOptions };

package/dist/cli/config/resolvers/compatibility.mjs

@@ -0,0 +1,90 @@
+import { resolveCompatibilityDatesFromEnv, formatDate } from 'compatx';
+import consola from 'consola';
+import { colors } from 'consola/utils';
+import { relative } from 'pathe';
+
+const fallbackCompatibilityDate = "2025-02-04";
+async function resolveCompatibilityOptions(options) {
+  options.compatibilityDate = resolveCompatibilityDatesFromEnv(
+    options.compatibilityDate
+  );
+  if (!options.compatibilityDate.default) {
+    options.compatibilityDate.default = await _resolveDefault(options);
+  }
+}
+let _fallbackInfoShown = false;
+let _promptedUserToUpdate = false;
+async function _resolveDefault(options) {
+  const _todayDate = formatDate(/* @__PURE__ */ new Date());
+  const consola$1 = consola.withTag("silgi");
+  consola$1.warn(`No valid compatibility date is specified.`);
+  const onFallback = () => {
+    if (!_fallbackInfoShown) {
+      consola$1.info(
+        [
+          `Using \`${fallbackCompatibilityDate}\` as fallback.`,
+          `  Please specify compatibility date to avoid unwanted behavior changes:`,
+          `     - Add \`compatibilityDate: '${_todayDate}'\` to the config file.`,
+          `     - Or set \`COMPATIBILITY_DATE=${_todayDate}\` environment variable.`,
+          ``
+        ].join("\n")
+      );
+      _fallbackInfoShown = true;
+    }
+    return fallbackCompatibilityDate;
+  };
+  const shallUpdate = !_promptedUserToUpdate && await consola$1.prompt(
+    `Do you want to auto update config file to set ${colors.cyan(`compatibilityDate: '${_todayDate}'`)}?`,
+    {
+      type: "confirm",
+      default: true
+    }
+  );
+  _promptedUserToUpdate = true;
+  if (!shallUpdate) {
+    return onFallback();
+  }
+  const { updateConfig } = await import('c12/update');
+  const updateResult = await updateConfig({
+    configFile: "silgi.config",
+    cwd: options.rootDir,
+    async onCreate({ configFile }) {
+      const shallCreate = await consola$1.prompt(
+        `Do you want to initialize a new config in ${colors.cyan(relative(".", configFile))}?`,
+        {
+          type: "confirm",
+          default: true
+        }
+      );
+      if (shallCreate !== true) {
+        return false;
+      }
+      return _getDefaultNitroConfig();
+    },
+    async onUpdate(config) {
+      config.compatibilityDate = _todayDate;
+    }
+  }).catch((error) => {
+    consola$1.error(`Failed to update config: ${error.message}`);
+    return null;
+  });
+  if (updateResult?.configFile) {
+    consola$1.success(
+      `Compatibility date set to \`${_todayDate}\` in \`${relative(".", updateResult.configFile)}\``
+    );
+    return _todayDate;
+  }
+  return onFallback();
+}
+function _getDefaultNitroConfig() {
+  return (
+    /* js */
+    `
+import { defineSilgiConfig } from 'silgi/config'
+
+export default defineSilgiConfig({})
+  `
+  );
+}
+
+export { fallbackCompatibilityDate, resolveCompatibilityOptions };