silgi 0.7.1 → 0.7.2

package/dist/ecosystem/nitro/index.mjs

@@ -1 +1,62 @@
-export { default } from './module.mjs';
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { resolve, dirname, join } from 'pathe';
+import { loadOptions } from 'silgi/cli/config';
+import { relativeWithDot } from 'silgi/kit';
+import { autoImportTypes } from 'silgi/types';
+
+const module = {
+  name: "silgi",
+  setup: async (nitro) => {
+    const silgiConfig = await loadOptions({});
+    nitro.options.plugins = nitro.options.plugins || [];
+    nitro.options.plugins.push(
+      fileURLToPath(new URL("runtime/plugin", import.meta.url))
+    );
+    const tsConfigPath = resolve(
+      nitro.options.buildDir,
+      nitro.options.typescript.tsconfigPath
+    );
+    const tsconfigDir = dirname(tsConfigPath);
+    nitro.options.typescript.strict = true;
+    nitro.options.typescript.tsConfig ??= {};
+    nitro.options.typescript.tsConfig.extends = "./silgi.tsconfig.json";
+    nitro.options.typescript.tsConfig.include ??= [];
+    nitro.options.typescript.tsConfig.exclude ??= [];
+    if (silgiConfig.typescript.internalPaths || silgiConfig.stub) {
+      nitro.options.alias ||= {};
+      nitro.options.alias = {
+        ...nitro.options.alias,
+        ...silgiConfig.alias
+        // 'silgi/runtime': fileURLToPath(`${new URL(pkgDir, import.meta.url)}dist/runtime/`),
+      };
+    }
+    nitro.options.typescript.tsConfig.include.push(join(relativeWithDot(tsconfigDir, silgiConfig.build.dir), "**/*"));
+    nitro.options.typescript.tsConfig.compilerOptions ??= {};
+    nitro.options.typescript.tsConfig.compilerOptions.paths ??= {};
+    nitro.hooks.hook("types:extend", async () => {
+      const isStub = silgiConfig.stub ? "pnpm silgi prepare --stub" : "pnpm silgi prepare";
+      execSync(isStub, { stdio: "inherit", cwd: nitro.options.rootDir, env: process.env });
+    });
+    nitro.options.exportConditions ??= [];
+    nitro.options.exportConditions.push(...silgiConfig.conditions);
+    if (nitro.options.imports) {
+      nitro.options.imports.dirs ??= [];
+      nitro.options.imports.dirs.push(
+        join(silgiConfig.silgi.serverDir, "**/*")
+      );
+      nitro.options.imports.presets ??= [];
+      nitro.options.imports.presets.push({
+        from: "silgi",
+        imports: ["silgi"]
+      });
+      nitro.options.imports.presets.push({
+        from: "silgi/types",
+        imports: autoImportTypes.map((type) => type),
+        type: true
+      });
+    }
+  }
+};
+
+export { module as default };

package/dist/ecosystem/nuxt/module.mjs

@@ -1,7 +1,7 @@
 import { defineNuxtModule, addImports } from '@nuxt/kit';
 import { resolvePath } from 'mlly';
 import { join } from 'pathe';
-import { loadOptions } from 'silgi/core';
+import { loadOptions } from 'silgi/cli/config';
 import { relativeWithDot } from 'silgi/kit';
 import { autoImportTypes } from 'silgi/types';
 

package/dist/kit/index.mjs

@@ -1,10 +1,299 @@
-export { tryResolveModule } from './esm.mjs';
-export { isDirectory, writeFile } from './fs.mjs';
-export { isH3, isNitro, isNuxt } from './isFramework.mjs';
-export { useLogger } from './logger.mjs';
-export { defineSilgiModule } from './module.mjs';
-export { prettyPath, resolveSilgiPath } from './path.mjs';
-export { defineSilgiPreset } from './preset.mjs';
-export { createResolver, resolveAlias, resolvePath, resolveSilgiModule } from './resolve.mjs';
-export { addTemplate, normalizeTemplate } from './template.mjs';
-export { MODE_RE, filterInPlace, relativeWithDot, toArray } from './utils.mjs';
+import { resolvePath as resolvePath$1 } from 'mlly';
+import fsp from 'node:fs/promises';
+import consola, { consola as consola$1 } from 'consola';
+import { relative, resolve, dirname, normalize, isAbsolute, join, parse, basename } from 'pathe';
+import { colors } from 'consola/utils';
+import { getProperty } from 'dot-prop';
+import { useSilgi, tryUseSilgiCLI, useSilgiCLI } from 'silgi/core';
+import { defu } from 'defu';
+import { c as checkSilgiCompatibility } from '../cli/compatibility.mjs';
+import { existsSync, promises } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { resolveAlias as resolveAlias$1 } from 'pathe/utils';
+import { hash } from 'ohash';
+import 'semver/functions/satisfies.js';
+import 'silgi/meta';
+
+async function tryResolveModule(id, url = import.meta.url) {
+  try {
+    return await resolvePath$1(id, { url });
+  } catch {
+  }
+}
+
+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}`;
+  });
+}
+
+async function writeFile(file, contents, log = false) {
+  await fsp.mkdir(dirname(file), { recursive: true });
+  await fsp.writeFile(
+    file,
+    contents,
+    typeof contents === "string" ? "utf8" : void 0
+  );
+  if (log) {
+    consola$1.info("Generated", prettyPath(file));
+  }
+}
+async function isDirectory$1(path) {
+  try {
+    return (await fsp.stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function isNuxt() {
+  const silgi = useSilgi();
+  if (silgi.options.present === "nitro" || silgi.options.present === "h3" || silgi.options.present === "nuxt") {
+    return true;
+  }
+  return false;
+}
+function isNitro() {
+  const silgi = useSilgi();
+  if (silgi.options.present === "nitro" || silgi.options.present === "h3") {
+    return true;
+  }
+  return false;
+}
+function isH3() {
+  const silgi = useSilgi();
+  if (silgi.options.present === "h3") {
+    return true;
+  }
+  return false;
+}
+
+const logger = consola$1;
+function useLogger(tag, options = {}) {
+  return tag ? logger.create(options).withTag(tag) : logger;
+}
+
+function defineSilgiModule(definition) {
+  if (definition) {
+    return _defineSilgiModule(definition);
+  }
+  return {
+    with: (definition2) => _defineSilgiModule(definition2)
+  };
+}
+function _defineSilgiModule(definition) {
+  if (typeof definition === "function") {
+    return _defineSilgiModule({ setup: definition });
+  }
+  const module = defu(definition, { meta: {} });
+  module.meta.configKey ||= module.meta.name;
+  async function getOptions(inlineOptions, silgi = useSilgiCLI()) {
+    const nuxtConfigOptionsKey = module.meta.configKey || module.meta.name;
+    const nuxtConfigOptions = nuxtConfigOptionsKey && nuxtConfigOptionsKey in silgi.options ? silgi.options[nuxtConfigOptionsKey] : {};
+    const optionsDefaults = module.defaults instanceof Function ? await module.defaults(silgi) : module.defaults ?? {};
+    const options = defu(inlineOptions, nuxtConfigOptions, optionsDefaults);
+    return Promise.resolve(options);
+  }
+  async function silgiNormalizedModule(inlineOptions, silgi = tryUseSilgiCLI()) {
+    if (!silgi) {
+      throw new TypeError("Cannot use module outside of Silgi context");
+    }
+    const uniqueKey = module.meta.configKey || module.meta.name;
+    if (uniqueKey) {
+      silgi._requiredModules ||= {};
+      if (silgi._requiredModules[uniqueKey]) {
+        return false;
+      }
+      silgi._requiredModules[uniqueKey] = true;
+    }
+    if (module.meta.compatibility) {
+      const issues = await checkSilgiCompatibility(module.meta.compatibility, silgi);
+      if (issues.length) {
+        silgi.logger.warn(`Module \`${module.meta.name}\` is disabled due to incompatibility issues:
+${issues.toString()}`);
+        return;
+      }
+    }
+    const _options = await getOptions(inlineOptions, silgi);
+    if (module.hooks) {
+      silgi.hooks.addHooks(module.hooks);
+    }
+    const start = performance.now();
+    const res = await module.setup?.call(null, _options, silgi) ?? {};
+    const perf = performance.now() - start;
+    const setupTime = Math.round(perf * 100) / 100;
+    if (setupTime > 5e3 && uniqueKey !== "@silgi/telemetry") {
+      silgi.logger.warn(`Slow module \`${uniqueKey || "<no name>"}\` took \`${setupTime}ms\` to setup.`);
+    } else if (silgi.options.debug) {
+      silgi.logger.info(`Module \`${uniqueKey || "<no name>"}\` took \`${setupTime}ms\` to setup.`);
+    }
+    if (res === false) {
+      return false;
+    }
+    return defu(res, {
+      timings: {
+        setup: setupTime
+      }
+    });
+  }
+  silgiNormalizedModule.getMeta = () => Promise.resolve(module.meta);
+  silgiNormalizedModule.getOptions = getOptions;
+  return silgiNormalizedModule;
+}
+
+function defineSilgiPreset(preset, meta) {
+  if (meta?.url && typeof preset !== "function") ;
+  return { ...preset, _meta: meta };
+}
+
+async function resolvePath(path, opts = {}) {
+  const _path = path;
+  path = normalize(path);
+  if (isAbsolute(path)) {
+    if (existsSync(path) && !await isDirectory(path)) {
+      return path;
+    }
+  }
+  const cwd = opts.cwd || process.cwd();
+  const extensions = opts.extensions || [".ts", ".mjs", ".cjs", ".json"];
+  const modulesDir = opts.modulesDir || [];
+  path = resolveAlias(path);
+  if (!isAbsolute(path)) {
+    path = resolve(cwd, path);
+  }
+  let _isDir = false;
+  if (existsSync(path)) {
+    _isDir = await isDirectory(path);
+    if (!_isDir) {
+      return path;
+    }
+  }
+  for (const ext of extensions) {
+    const pathWithExt = path + ext;
+    if (existsSync(pathWithExt)) {
+      return pathWithExt;
+    }
+    const pathWithIndex = join(path, `index${ext}`);
+    if (_isDir && existsSync(pathWithIndex)) {
+      return pathWithIndex;
+    }
+  }
+  const resolveModulePath = await resolvePath$1(_path, { url: [cwd, ...modulesDir] }).catch(() => null);
+  if (resolveModulePath) {
+    return resolveModulePath;
+  }
+  return opts.fallbackToOriginal ? _path : path;
+}
+async function isDirectory(path) {
+  return (await promises.lstat(path)).isDirectory();
+}
+function resolveAlias(path, alias) {
+  return resolveAlias$1(path, alias || {});
+}
+function createResolver(base) {
+  if (!base) {
+    throw new Error("`base` argument is missing for createResolver(base)!");
+  }
+  base = base.toString();
+  if (base.startsWith("file://")) {
+    base = dirname(fileURLToPath(base));
+  }
+  return {
+    resolve: (...path) => resolve(base, ...path),
+    resolvePath: (path, opts) => resolvePath(path, { cwd: base, ...opts })
+  };
+}
+async function resolveSilgiModule(base, paths) {
+  const resolved = [];
+  const resolver = createResolver(base);
+  for (const path of paths) {
+    if (path.startsWith(base)) {
+      resolved.push(path.split("/index.ts")[0]);
+    } else {
+      const resolvedPath = await resolver.resolvePath(path);
+      resolved.push(resolvedPath.slice(0, resolvedPath.lastIndexOf(path) + path.length));
+    }
+  }
+  return resolved;
+}
+
+const RELATIVE_RE = /^([^.])/;
+function relativeWithDot(from, to) {
+  return relative(from, to).replace(RELATIVE_RE, "./$1") || ".";
+}
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function filterInPlace(array, predicate) {
+  for (let i = array.length; i--; i >= 0) {
+    if (!predicate(array[i], i, array)) {
+      array.splice(i, 1);
+    }
+  }
+  return array;
+}
+const MODE_RE = /\.(server|client)(\.\w+)*$/;
+
+function addTemplate(_template) {
+  const silgi = useSilgiCLI();
+  const template = normalizeTemplate(_template);
+  filterInPlace(silgi.options.build.templates, (p) => normalizeTemplate(p).dst !== template.dst);
+  silgi.options.build.templates.push(template);
+  return template;
+}
+function normalizeTemplate(template, buildDir) {
+  if (!template) {
+    throw new Error(`Invalid template: ${JSON.stringify(template)}`);
+  }
+  if (typeof template === "string") {
+    template = { src: template };
+  } else {
+    template = { ...template };
+  }
+  if (template.src) {
+    if (!existsSync(template.src)) {
+      throw new Error(`Template not found: ${template.src}`);
+    }
+    if (!template.filename) {
+      const srcPath = parse(template.src);
+      template.filename = template.fileName || `${basename(srcPath.dir)}.${srcPath.name}.${hash(template.src)}${srcPath.ext}`;
+    }
+  }
+  if (!template.src && !template.getContents) {
+    throw new Error(`Invalid template. Either \`getContents\` or \`src\` should be provided: ${JSON.stringify(template)}`);
+  }
+  if (!template.filename) {
+    throw new Error(`Invalid template. \`filename\` must be provided: ${JSON.stringify(template)}`);
+  }
+  if (template.filename.endsWith(".d.ts")) {
+    template.write = true;
+  }
+  if (!template.dst) {
+    template.dst = resolve(buildDir ?? useSilgiCLI().options.silgi.serverDir, template.filename);
+  }
+  return template;
+}
+
+export { MODE_RE, addTemplate, createResolver, defineSilgiModule, defineSilgiPreset, filterInPlace, isDirectory$1 as isDirectory, isH3, isNitro, isNuxt, normalizeTemplate, prettyPath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, toArray, tryResolveModule, useLogger, writeFile };

package/dist/meta/index.d.mts

@@ -1,3 +1,3 @@
-const version = "0.7.1";
+const version = "0.7.2";
 
 export { version };

package/dist/meta/index.d.ts

@@ -1,3 +1,3 @@
-const version = "0.7.1";
+const version = "0.7.2";
 
 export { version };

package/dist/meta/index.mjs

@@ -1 +1 @@
-export { version } from '../package.json.mjs';
+export { v as version } from '../_chunks/index.mjs';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "private": false,
   "sideEffects": false,
   "exports": {
@@ -9,6 +9,10 @@
       "types": "./cli.d.ts",
       "import": "./dist/cli/index.mjs"
     },
+    "./cli/config": {
+      "types": "./dist/cli/config/index.d.ts",
+      "import": "./dist/cli/config/index.mjs"
+    },
     "./config": {
       "types": "./config.d.ts",
       "import": "./dist/config/index.mjs"

package/dist/cli/build/framework/h3.mjs

@@ -1,46 +0,0 @@
-async function h3Framework(silgi, skip = false) {
-  if (silgi.options.preset !== "h3" && skip === false)
-    return;
-  if (silgi.options.preset === "h3") {
-    silgi.hook("after:prepare:schema.ts", (data) => {
-      data.unshift("type FrameworkContextExtends = NitroApp");
-    });
-  }
-  silgi.hook("prepare:schema.ts", (data) => {
-    data.importItems.nitropack = {
-      import: [
-        { name: "NitroApp", type: true }
-      ],
-      from: "nitropack/types"
-    };
-    data.importItems.h3 = {
-      import: [
-        { name: "H3Event", type: true }
-      ],
-      from: "h3"
-    };
-    data.events.push({
-      key: "H3Event",
-      value: "H3Event",
-      extends: true,
-      isSilgiContext: false
-    });
-  });
-  silgi.hook("prepare:createDTSFramework", (data) => {
-    data.importItems["silgi/types"] = {
-      import: [
-        { name: "ModuleRuntimeContext", type: true }
-      ],
-      from: "silgi/types"
-    };
-    data.customContent?.push(
-      "",
-      'declare module "h3" {',
-      "  interface H3EventContext extends ModuleRuntimeContext {}",
-      "}",
-      ""
-    );
-  });
-}
-
-export { h3Framework };

package/dist/cli/build/framework/index.mjs

@@ -1,7 +0,0 @@
-import { h3Framework } from './h3.mjs';
-import { nitroFramework } from './nitro.mjs';
-import { nuxtFramework } from './nuxt.mjs';
-
-const frameworkSetup = [h3Framework, nitroFramework, nuxtFramework];
-
-export { frameworkSetup };

package/dist/cli/build/framework/nitro.mjs

@@ -1,28 +0,0 @@
-import { join } from 'pathe';
-import { runtimeDir } from 'silgi/runtime/meta';
-import { h3Framework } from './h3.mjs';
-
-async function nitroFramework(silgi, skip = false) {
-  if (silgi.options.preset !== "nitro" && skip === false)
-    return;
-  silgi.hook("prepare:schema.ts", (data) => {
-    data.importItems.nitropack = {
-      import: [
-        { name: "NitroApp", type: true }
-      ],
-      from: "nitropack/types"
-    };
-  });
-  silgi.hook("after:prepare:schema.ts", (data) => {
-    data.unshift("type FrameworkContextExtends = NitroApp");
-  });
-  silgi.options.plugins.push({
-    packageImport: "silgi/runtime/internal/nitro",
-    path: join(runtimeDir, "internal/nitro")
-  });
-  silgi.hook("prepare:core.ts", (_data) => {
-  });
-  await h3Framework(silgi, true);
-}
-
-export { nitroFramework };

package/dist/cli/build/framework/nuxt.mjs

@@ -1,9 +0,0 @@
-import { nitroFramework } from './nitro.mjs';
-
-async function nuxtFramework(silgi, skip = false) {
-  if (silgi.options.preset !== "nuxt" && skip === false)
-    return;
-  await nitroFramework(silgi, true);
-}
-
-export { nuxtFramework };

package/dist/cli/build/prepare.mjs

@@ -1,7 +0,0 @@
-import 'node:fs';
-import 'node:fs/promises';
-
-async function prepare(_silgi) {
-}
-
-export { prepare };

package/dist/cli/build/scanURIs.mjs

@@ -1,27 +0,0 @@
-import { promises } from 'node:fs';
-import { readCoreFile } from '../utils/readCoreFile.mjs';
-import { traverseObject, scanActionModulesUris } from '../utils/uri.mjs';
-
-async function scanUris(silgi) {
-  const { context, object, path } = await readCoreFile(silgi);
-  const uriMap = traverseObject(silgi, object.schemas, []);
-  const modulesURIs = scanActionModulesUris(silgi, object.services, []);
-  const uriContent = Array.from(uriMap.entries()).map(([uri, params]) => `  '${uri}': '${params}',`).join("\n");
-  let newContext = "";
-  if (uriMap.size > 0) {
-    newContext = context.replace(
-      /export const uris = \{[^}]*\}/,
-      `export const uris = {
-${uriContent}
-}`
-    ).replace(
-      /export const modulesURIs = \{[^}]*\}/,
-      `export const modulesURIs = ${JSON.stringify(modulesURIs, null, 2)}`
-    );
-  } else {
-    newContext = context;
-  }
-  await promises.writeFile(path, newContext);
-}
-
-export { scanUris };

package/dist/cli/build/template/framework.mjs

@@ -1,91 +0,0 @@
-import { isAbsolute } from 'pathe';
-import { readPackageJSON } from 'pkg-types';
-import { relativeWithDot } from 'silgi/kit';
-
-async function createCoreFramework(silgi) {
-  const relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
-  if (silgi.options.preset !== "nitro" && silgi.options.preset !== "h3")
-    return;
-  const importItems = {
-    "silgi/types": {
-      import: [
-        { name: "ModuleRuntimeContext", type: true }
-      ],
-      from: "silgi/types"
-    }
-  };
-  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
-    if (typeof id !== "string") {
-      return;
-    }
-    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
-    if (!pkg?.name) {
-      return;
-    }
-    if (importItems[pkg.name]) {
-      importItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
-    }
-  }));
-  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 relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
-  const importItems = {
-    "silgi/types": {
-      import: [
-        { name: "ModuleRuntimeContext", type: true }
-      ],
-      from: "silgi/types"
-    }
-  };
-  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
-    if (typeof id !== "string") {
-      return;
-    }
-    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
-    if (!pkg?.name) {
-      return;
-    }
-    if (importItems[pkg.name]) {
-      importItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
-    }
-  }));
-  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;
-      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
-    }),
-    "",
-    ...customImports,
-    "",
-    ...customContent,
-    ""
-  ];
-  return {
-    content,
-    importItems
-  };
-}
-
-export { createCoreFramework, createDTSFramework };