silgi 0.24.17 → 0.24.19

package/dist/_chunks/path.mjs

@@ -0,0 +1,62 @@
+import satisfies from 'semver/functions/satisfies.js';
+import { useSilgi } from 'silgi';
+import { version } from 'silgi/meta';
+import consola from 'consola';
+import { colors } from 'consola/utils';
+import { getProperty } from 'dot-prop';
+import { relative, resolve } from 'pathe';
+
+const SEMANTIC_VERSION_RE = /-\d+\.[0-9a-f]+/;
+function normalizeSemanticVersion(version) {
+  return version.replace(SEMANTIC_VERSION_RE, "");
+}
+const SILGI_VERSION_RE = /^v/g;
+async function checkSilgiCompatibility(constraints, silgi = useSilgi()) {
+  const issues = [];
+  if (constraints.silgi) {
+    const _silgiVersion = version.replace(SILGI_VERSION_RE, "");
+    if (!satisfies(normalizeSemanticVersion(_silgiVersion), constraints.silgi, { includePrerelease: true })) {
+      issues.push({
+        name: "silgi",
+        message: `Silgi version \`${constraints.silgi}\` is required but currently using \`${version}\``
+      });
+    }
+  }
+  await silgi.callHook("kit:compatibility", constraints, issues);
+  issues.toString = () => issues.map((issue) => ` - [${issue.name}] ${issue.message}`).join("\n");
+  return issues;
+}
+function hasInstalledModule(moduleKey, silgi = useSilgi()) {
+  const find = silgi.scanModules.find(({ meta }) => meta.configKey === moduleKey);
+  return find?.installed ?? false;
+}
+
+function prettyPath(p, highlight = true) {
+  p = relative(process.cwd(), p);
+  return highlight ? colors.cyan(p) : p;
+}
+function resolveSilgiPath(path, silgiCLIOptions, base) {
+  if (typeof path !== "string") {
+    throw new TypeError(`Invalid path: ${path}`);
+  }
+  path = _compilePathTemplate(path)(silgiCLIOptions);
+  for (const base2 in silgiCLIOptions.alias) {
+    if (path.startsWith(base2)) {
+      path = silgiCLIOptions.alias[base2] + path.slice(base2.length);
+    }
+  }
+  return resolve(base || silgiCLIOptions.srcDir, path);
+}
+function _compilePathTemplate(contents) {
+  return (params) => contents.replace(/\{\{ ?([\w.]+) ?\}\}/g, (_, match) => {
+    const val = getProperty(params, match);
+    if (!val) {
+      consola.warn(
+        `cannot resolve template param '${match}' in ${contents.slice(0, 20)}`
+      );
+    }
+    return val || `${match}`;
+  });
+}
+
+export { checkSilgiCompatibility as c, hasInstalledModule as h, prettyPath as p, resolveSilgiPath as r };

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

@@ -3,12 +3,15 @@ import { watch } from 'chokidar';
 import { defineCommand, runCommand } from 'citty';
 import consola from 'consola';
 import { join } from 'pathe';
-import { useSilgiCLI } from 'silgi';
+import { useSilgi, reloadScan, silgiClose } from 'silgi';
 import { version } from 'silgi/meta';
-import { silgiCLIIClose } from '../../core/silgiApp.mjs';
-import { reloadScan } from '../core/devServer.mjs';
-import { commonArgs } from '../utils/common.mjs';
-import prepare from './prepare.mjs';
+import { c as commonArgs, p as prepare } from './prepare.mjs';
+import 'node:child_process';
+import 'node:fs';
+import '@clack/prompts';
+import 'dev-jiti';
+import 'picocolors';
+import './env.mjs';
 
 const dev = defineCommand({
   meta: {
@@ -31,7 +34,7 @@ const dev = defineCommand({
     await runCommand(prepare, {
       rawArgs: ["--commands", "run", "--dev", "true"]
     });
-    const silgi = useSilgiCLI();
+    const silgi = useSilgi();
     silgi.options.watchOptions.ignored ??= [];
     silgi.options.watchOptions.ignoreInitial = true;
     if (Array.isArray(silgi.options.watchOptions.ignored)) {
@@ -80,7 +83,7 @@ const dev = defineCommand({
       if (watcher) {
         watcher.close();
       }
-      await silgiCLIIClose();
+      await silgiClose();
       process.exit(0);
     });
     consola.withTag("silgi").success("Prepare completed");

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

@@ -1,5 +1,5 @@
 import * as p from '@clack/prompts';
-import { setupDotenv } from '../core/env.mjs';
+import { setupDotenv } from 'silgi';
 
 let initialized = false;
 async function prepareEnv(silgiConfig) {
@@ -37,4 +37,4 @@ async function prepareEnv(silgiConfig) {
   }
 }
 
-export { prepareEnv };
+export { prepareEnv as p };

package/dist/cli/index.mjs

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
-import packageJson from '../package.json.mjs';
+
+const version = "0.24.19";
+const packageJson = {
+	version: version};
 
 const main = defineCommand({
   meta: {
@@ -15,11 +18,11 @@ const main = defineCommand({
     }
   },
   subCommands: {
-    prepare: () => import('./commands/prepare.mjs').then((m) => m.default),
-    init: () => import('./commands/init.mjs').then((m) => m.default),
-    run: () => import('./commands/run.mjs').then((m) => m.default),
-    install: () => import('./commands/install.mjs').then((m) => m.default),
-    dev: () => import('./commands/dev.mjs').then((m) => m.default)
+    prepare: () => import('./prepare.mjs').then(function (n) { return n.a; }).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),
+    install: () => import('./install.mjs').then((m) => m.default),
+    dev: () => import('./dev.mjs').then((m) => m.default)
   },
   run({ args }) {
     if (args.version)

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

@@ -3,10 +3,13 @@ import { readFileSync } from 'node:fs';
 import { defineCommand, runCommand } from 'citty';
 import { consola } from 'consola';
 import { resolve } from 'pathe';
+import { loadOptions } from 'silgi';
 import { version } from 'silgi/meta';
-import { commonArgs } from '../utils/common.mjs';
-import prepare from './prepare.mjs';
-import { loadOptions } from '../config/loader.mjs';
+import { c as commonArgs, p as prepare } from './prepare.mjs';
+import '@clack/prompts';
+import 'dev-jiti';
+import 'picocolors';
+import './env.mjs';
 
 const install = defineCommand({
   meta: {

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

@@ -1,18 +1,26 @@
+import { defineCommand, runCommand } from 'citty';
+import { resolve } from 'pathe';
+import { useSilgi, loadOptions, silgiClose, createSilgi, prepare as prepare$2, writeTypesAndFiles, writeCoreFile, prepareBuild } from 'silgi';
+import { version } from 'silgi/meta';
 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 { 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';
+import { p as prepareEnv } from './env.mjs';
+
+const commonArgs = {
+  dir: {
+    type: "string",
+    description: "project root directory"
+  },
+  _dir: {
+    type: "positional",
+    default: ".",
+    description: "project root directory (prefer using `--dir`)"
+  }
+};
 
 const run = defineCommand({
   meta: {
@@ -43,7 +51,7 @@ const run = defineCommand({
       consola.error("Silgi not found");
       return;
     }
-    const silgi = useSilgiCLI();
+    const silgi = useSilgi();
     const tags = args.tag?.split(",").map((t) => t.trim());
     p.intro(color.bold(`Silgi CLI ${color.green(`v${version}`)}`));
     const silgiConfig = await loadOptions({});
@@ -157,7 +165,7 @@ const run = defineCommand({
           alias: silgiConfig.alias
         });
         let cleanHandler = cmd.handler.handler.replace(/\n/g, "");
-        cleanHandler = `import { silgiCLICtx } from 'silgi' 
+        cleanHandler = `import { silgiCtx } from 'silgi' 
         ${cleanHandler}
 `;
         await jiti.evalModule(cleanHandler, {
@@ -168,8 +176,72 @@ const run = defineCommand({
         });
       }
     }
-    await silgiCLIIClose();
+    await silgiClose();
   }
 });
 
-export { run as default };
+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 createSilgi({
+      rootDir,
+      dev: args.dev || args.stub,
+      stub: args.stub,
+      preset: args.preset,
+      commandType: "prepare",
+      activeEnvironment: args.env
+    });
+    await prepare$2(silgi);
+    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 };

package/dist/index.d.mts

@@ -1,22 +1,30 @@
-import { SilgiCLI, SilgiCLIConfig, LoadConfigOptions, SilgiConfig, Silgi, SilgiEvents, SilgiFunction, SilgiOperation, MergedSilgiSchema, ServiceType, SilgiSchema, RequiredServiceType, SilgiRuntimeSharedsExtend, SilgiRuntimeContext, DefaultNamespaces, BaseSchemaType, SilgiRuntimeShareds, StorageConfig, SilgiStorageBase } from 'silgi/types';
+import * as unctx from 'unctx';
+import { Silgi, SilgiCLI, SilgiConfig, SilgiEvents, SilgiFunction, SilgiOperation, MergedSilgiSchema, ServiceType, SilgiSchema, RequiredServiceType, SilgiRuntimeSharedsExtend, SilgiRuntimeContext, DefaultNamespaces, BaseSchemaType, SilgiRuntimeShareds, StorageConfig, SilgiStorageBase, SilgiCLIConfig, LoadConfigOptions, SilgiCLIOptions, DotenvOptions } from 'silgi/types';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { Storage, StorageValue } from 'unstorage';
-import * as unctx from 'unctx';
+import { Stats } from 'node:fs';
 
+declare const silgiAppCtx: unctx.UseContext<Silgi>;
+declare const silgiCtx: unctx.UseContext<SilgiCLI>;
+declare function useSilgiApp(): Silgi;
 /**
- * Prepares route rules for the build
+ * Get access to Nuxt instance.
+ *
+ * Returns null if Nuxt instance is unavailable.
+ * @example
+ * ```js
+ * const silgi = tryUseSilgiApp()
+ * if (silgi) {
+ *  // Do something
+ * }
+ * ```
  */
-declare function prepareBuild(silgi: SilgiCLI): Promise<void>;
+declare function tryUseSilgiApp(): Silgi | null;
+declare function useSilgi(): SilgiCLI;
+declare function silgiClose(): Promise<void>;
+declare function tryUseSilgi(): SilgiCLI | null;
 
-declare function prepare(_silgi: SilgiCLI): Promise<void>;
-
-declare function createSilgiCLI(config?: SilgiCLIConfig, opts?: LoadConfigOptions): Promise<SilgiCLI>;
-
-declare function writeCoreFile(silgi: SilgiCLI): Promise<void>;
-
-declare function writeTypesAndFiles(silgi: SilgiCLI): Promise<void>;
-
-declare function createSilgi(config: SilgiConfig): Promise<Silgi>;
+declare function createSilgiApp(config: SilgiConfig): Promise<Silgi>;
 
 declare function silgi(event?: SilgiEvents | Record<string, any>): SilgiFunction;
 
@@ -244,41 +252,34 @@ declare class SilgiError extends Error implements BaseError {
 }
 declare function isBaseError(error: unknown): error is BaseError;
 
-declare const silgiCtx: unctx.UseContext<Silgi>;
-declare function useSilgi(): Silgi;
+declare function storageMount<T extends Storage = Storage>(silgi?: Silgi): (base: keyof SilgiStorageBase, driver: Parameters<Storage['mount']>[1]) => T;
+
+declare function loadOptions(configOverrides?: SilgiCLIConfig, opts?: LoadConfigOptions): Promise<SilgiCLIOptions>;
+
 /**
- * Get access to Nuxt instance.
- *
- * Returns null if Nuxt instance is unavailable.
- * @example
- * ```js
- * const silgi = tryUseSilgi()
- * if (silgi) {
- *  // Do something
- * }
- * ```
+ * Prepares route rules for the build
  */
-declare function tryUseSilgi(): Silgi | null;
+declare function prepareBuild(silgi: SilgiCLI): Promise<void>;
+
+declare function prepare(_silgi: SilgiCLI): Promise<void>;
+
+declare function reloadScan(path: string, _stats?: Stats): Promise<void>;
 
-declare const silgiCLICtx: unctx.UseContext<SilgiCLI>;
-declare function useSilgiCLI(): SilgiCLI;
+type Env = typeof process.env;
 /**
- * Get access to Nuxt instance.
+ * Load and interpolate environment variables into `process.env`.
+ * If you need more control (or access to the values), consider using `loadDotenv` instead
  *
- * Returns null if Nuxt instance is unavailable.
- * @example
- * ```js
- * const silgi = tryUseSilgi()
- * if (silgi) {
- *  // Do something
- * }
- * ```
  */
-declare function tryUseSilgiCLI(): SilgiCLI | null;
+declare function setupDotenv(options: DotenvOptions): Promise<Env>;
 
-declare function storageMount<T extends Storage = Storage>(silgi?: Silgi): (base: keyof SilgiStorageBase, driver: Parameters<Storage['mount']>[1]) => T;
+declare function createSilgi(config?: SilgiCLIConfig, opts?: LoadConfigOptions): Promise<SilgiCLI>;
+
+declare function writeCoreFile(silgi: SilgiCLI): Promise<void>;
+
+declare function writeTypesAndFiles(silgi: SilgiCLI): Promise<void>;
 
 declare const autoImportTypes: string[];
 
-export { ErrorCategory, ErrorFactory, ErrorSeverity, HttpStatus, SilgiError, autoImportTypes, createSchema, createService, createShared, createSilgi, createSilgiCLI, createStorage, getEvent, getEventContext, isBaseError, mergeSchemas, mergeServices, mergeShared, parseURI, prepare, prepareBuild, replaceRuntimeValues, silgi, silgiCLICtx, silgiCtx, storageMount, tryUseSilgi, tryUseSilgiCLI, useSilgi, useSilgiCLI, useSilgiStorage, writeCoreFile, writeTypesAndFiles };
+export { ErrorCategory, ErrorFactory, ErrorSeverity, HttpStatus, SilgiError, autoImportTypes, createSchema, createService, createShared, createSilgi, createSilgiApp, createStorage, getEvent, getEventContext, isBaseError, loadOptions, mergeSchemas, mergeServices, mergeShared, parseURI, prepare, prepareBuild, reloadScan, replaceRuntimeValues, setupDotenv, silgi, silgiAppCtx, silgiClose, silgiCtx, storageMount, tryUseSilgi, tryUseSilgiApp, useSilgi, useSilgiApp, useSilgiStorage, writeCoreFile, writeTypesAndFiles };
 export type { BaseError, ErrorMetadata };