silgi 0.24.15 → 0.24.17

package/dist/cli/module/install.mjs

@@ -0,0 +1,59 @@
+import { createJiti } from 'dev-jiti';
+import { useSilgiCLI } from 'silgi';
+import { hasInstalledModule } from '../utils/compatibility.mjs';
+
+async function loadSilgiModuleInstance(silgiModule) {
+  if (typeof silgiModule === "string") {
+    throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
+  }
+  if (typeof silgiModule !== "function") {
+    throw new TypeError(`Nuxt module should be a function: ${silgiModule}`);
+  }
+  return { silgiModule };
+}
+async function installModules(silgi, prepare = false) {
+  silgi.options.isPreparingModules = prepare;
+  const jiti = createJiti(silgi.options.rootDir, {
+    alias: silgi.options.alias,
+    fsCache: true,
+    moduleCache: true
+  });
+  for (const module of silgi.scanModules) {
+    if (hasInstalledModule(module.meta.configKey) && !silgi.options.dev) {
+      silgi.logger.info(`Module ${module.meta.configKey} installed`);
+    }
+    try {
+      const silgiModule = module.entryPath !== void 0 ? await jiti.import(module.entryPath, {
+        default: true,
+        conditions: silgi.options.conditions
+      }) : module.module;
+      if (silgiModule.name !== "silgiNormalizedModule") {
+        silgi.scanModules = silgi.scanModules.filter((m) => m.entryPath !== module.entryPath);
+        continue;
+      }
+      await installModule(silgiModule, silgi, prepare);
+    } catch (err) {
+      silgi.logger.error(err);
+    }
+  }
+  silgi.options.isPreparingModules = false;
+}
+async function installModule(moduleToInstall, silgi = useSilgiCLI(), inlineOptions, prepare = false) {
+  const { silgiModule } = await loadSilgiModuleInstance(moduleToInstall);
+  const res = await silgiModule(inlineOptions || {}, silgi) ?? {};
+  if (res === false) {
+    return false;
+  }
+  const metaData = await silgiModule.getMeta?.();
+  if (prepare) {
+    return metaData;
+  }
+  const installedModule = silgi.scanModules.find((m) => m.meta.configKey === metaData?.configKey);
+  if (installedModule) {
+    installedModule.installed = true;
+  } else {
+    throw new Error(`Module ${metaData?.name} not found`);
+  }
+}
+
+export { installModules, loadSilgiModuleInstance };

package/dist/cli/module/scan.mjs

@@ -0,0 +1,227 @@
+import { existsSync, promises } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import 'consola';
+import defu from 'defu';
+import { createJiti } from 'dev-jiti';
+import { resolveModuleURL } from 'exsolve';
+import { resolve } from 'pathe';
+import { resolveAlias, directoryToURL } from 'silgi/kit';
+import { isRelative } from 'ufo';
+import { scanExports } from 'unimport';
+
+const MissingModuleMatcher = /Cannot find module\s+['"]?([^'")\s]+)['"]?/i;
+async function _resolveSilgiModule(silgiModule, silgi) {
+  let resolvedModulePath;
+  let buildTimeModuleMeta = {};
+  const jiti = createJiti(silgi.options.rootDir, {
+    alias: silgi.options.alias,
+    fsCache: true,
+    moduleCache: true
+  });
+  if (typeof silgiModule === "string") {
+    silgiModule = resolveAlias(silgiModule, silgi.options.alias);
+    if (isRelative(silgiModule)) {
+      silgiModule = resolve(silgi.options.rootDir, silgiModule);
+    }
+    try {
+      const src = resolveModuleURL(silgiModule, {
+        from: silgi.options.modulesDir.map((m) => directoryToURL(m.replace(/\/node_modules\/?$/, "/"))),
+        suffixes: ["silgi", "silgi/index", "module", "module/index", "", "index"],
+        extensions: [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"]
+        // Maybe add https://github.com/unjs/exsolve/blob/dfff3e9bbc4a3a173a2d56b9b9ff731ab15598be/src/resolve.ts#L7
+        // conditions: silgi.options.conditions,
+      });
+      resolvedModulePath = fileURLToPath(src);
+      const resolvedSilgiModule = await jiti.import(src, { default: true });
+      if (typeof resolvedSilgiModule !== "function") {
+        throw new TypeError(`Nuxt module should be a function: ${silgiModule}.`);
+      }
+      silgiModule = await jiti.import(src, {
+        default: true,
+        conditions: silgi.options.conditions
+      });
+      const moduleMetadataPath = new URL("module.json", src);
+      if (existsSync(moduleMetadataPath)) {
+        buildTimeModuleMeta = JSON.parse(await promises.readFile(moduleMetadataPath, "utf-8"));
+      } else {
+        if (typeof silgiModule === "function") {
+          const meta = await silgiModule.getMeta?.();
+          const _exports = await scanExports(resolvedModulePath, true);
+          buildTimeModuleMeta = {
+            ...meta,
+            exports: _exports.map(({ from, ...rest }) => rest)
+          };
+        }
+      }
+    } catch (error) {
+      const code = error.code;
+      if (code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED" || code === "ERR_MODULE_NOT_FOUND" || code === "ERR_UNSUPPORTED_DIR_IMPORT" || code === "ENOTDIR") {
+        throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
+      }
+      if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {
+        const module = MissingModuleMatcher.exec(error.message)?.[1];
+        if (module && !module.includes(silgiModule)) {
+          throw new TypeError(`Error while importing module \`${silgiModule}\`: ${error}`);
+        }
+      }
+    }
+  }
+  if (!buildTimeModuleMeta) {
+    throw new Error(`Module ${silgiModule} is not a valid Silgi module`);
+  }
+  if (typeof silgiModule === "function") {
+    if (!buildTimeModuleMeta.configKey) {
+      const meta = await silgiModule.getMeta?.();
+      buildTimeModuleMeta = {
+        ...meta,
+        exports: []
+      };
+    }
+    if (silgi.scanModules.some((m) => m.meta?.configKey === buildTimeModuleMeta.configKey)) {
+      throw new Error(`Module with key \`${buildTimeModuleMeta.configKey}\` already exists`);
+    }
+    const options = await silgiModule.getOptions?.() || {};
+    if (options) {
+      silgi.options._c12.config[buildTimeModuleMeta.configKey] = defu(
+        silgi.options._c12.config[buildTimeModuleMeta.configKey] || {},
+        options || {}
+      );
+    } else {
+      throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
+    }
+    silgi.scanModules.push({
+      meta: buildTimeModuleMeta,
+      entryPath: resolvedModulePath || void 0,
+      installed: false,
+      options,
+      module: silgiModule
+    });
+  }
+}
+async function scanModules(silgi) {
+  const _modules = [
+    ...silgi.options._modules,
+    ...silgi.options.modules
+  ];
+  for await (const mod of _modules) {
+    await _resolveSilgiModule(mod, silgi);
+  }
+  const moduleMap = new Map(
+    silgi.scanModules.map((m) => [m.meta?.configKey, m])
+  );
+  const graphData = createDependencyGraph(silgi.scanModules);
+  const sortedKeys = topologicalSort(graphData);
+  const modules = sortedKeys.map((key) => moduleMap.get(key)).filter((module) => Boolean(module));
+  silgi.scanModules = modules;
+}
+function createDependencyGraph(modules) {
+  const graph = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  modules.forEach((module) => {
+    const key = module.meta?.configKey;
+    if (key) {
+      graph.set(key, /* @__PURE__ */ new Set());
+      inDegree.set(key, 0);
+    }
+  });
+  modules.forEach((module) => {
+    const key = module.meta?.configKey;
+    if (!key) {
+      return;
+    }
+    const requiredDeps = module.meta?.requiredDependencies || [];
+    const beforeDeps = module.meta?.beforeDependencies || [];
+    const afterDeps = module.meta?.afterDependencies || [];
+    const processedDeps = /* @__PURE__ */ new Set();
+    requiredDeps.forEach((dep) => {
+      if (!graph.has(dep)) {
+        throw new Error(`Required dependency "${dep}" for module "${key}" is missing`);
+      }
+      graph.get(dep)?.add(key);
+      inDegree.set(key, (inDegree.get(key) || 0) + 1);
+      processedDeps.add(dep);
+    });
+    beforeDeps.forEach((dep) => {
+      if (!graph.has(dep)) {
+        return;
+      }
+      graph.get(key)?.add(dep);
+      inDegree.set(dep, (inDegree.get(dep) || 0) + 1);
+    });
+    afterDeps.forEach((dep) => {
+      if (processedDeps.has(dep)) {
+        return;
+      }
+      if (!graph.has(dep)) {
+        return;
+      }
+      graph.get(dep)?.add(key);
+      inDegree.set(key, (inDegree.get(key) || 0) + 1);
+    });
+  });
+  return { graph, inDegree };
+}
+function findCyclicDependencies(graph) {
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  const cycles = [];
+  function dfs(node, path = []) {
+    visited.add(node);
+    recursionStack.add(node);
+    path.push(node);
+    for (const neighbor of graph.get(node) || []) {
+      if (recursionStack.has(neighbor)) {
+        const cycleStart = path.indexOf(neighbor);
+        if (cycleStart !== -1) {
+          cycles.push([...path.slice(cycleStart), neighbor]);
+        }
+      } else if (!visited.has(neighbor)) {
+        dfs(neighbor, [...path]);
+      }
+    }
+    recursionStack.delete(node);
+    path.pop();
+  }
+  for (const node of graph.keys()) {
+    if (!visited.has(node)) {
+      dfs(node, []);
+    }
+  }
+  return cycles;
+}
+function topologicalSort(graphData) {
+  const { graph, inDegree } = graphData;
+  const order = [];
+  const queue = [];
+  for (const [node, degree] of inDegree.entries()) {
+    if (degree === 0) {
+      queue.push(node);
+    }
+  }
+  while (queue.length > 0) {
+    const node = queue.shift();
+    order.push(node);
+    const neighbors = Array.from(graph.get(node) || []);
+    for (const neighbor of neighbors) {
+      const newDegree = (inDegree.get(neighbor) || 0) - 1;
+      inDegree.set(neighbor, newDegree);
+      if (newDegree === 0) {
+        queue.push(neighbor);
+      }
+    }
+  }
+  if (order.length !== graph.size) {
+    const cycles = findCyclicDependencies(graph);
+    if (cycles.length > 0) {
+      const cycleStr = cycles.map((cycle) => `  ${cycle.join(" -> ")}`).join("\n");
+      throw new Error(`Circular dependencies detected:
+${cycleStr}`);
+    } else {
+      const unresolvedModules = Array.from(graph.keys()).filter((key) => !order.includes(key));
+      throw new Error(`Unable to resolve dependencies for modules: ${unresolvedModules.join(", ")}`);
+    }
+  }
+  return order;
+}
+
+export { scanModules };

package/dist/cli/scan/commands.mjs

@@ -0,0 +1,47 @@
+import { addTemplate } from 'silgi/kit';
+import { generateTypes, resolveSchema } from 'untyped';
+
+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);
+  });
+}
+
+export { commands };

package/dist/cli/scan/prepareConfigs.mjs

@@ -0,0 +1,46 @@
+import { genObjectFromRawEntries } from 'knitwork';
+import { genEnsureSafeVar } from 'silgi/kit';
+
+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 { useSilgiRuntimeConfig } from 'silgi/runtime'",
+    "",
+    `export const runtimeConfig: Partial<SilgiRuntimeConfig> = ${genObjectFromRawEntries(
+      Object.entries(_data.runtimeConfig).map(([key, value]) => [key, genEnsureSafeVar(value)]),
+      ""
+    )}`,
+    "",
+    "const runtime = useSilgiRuntimeConfig(undefined, runtimeConfig)",
+    ""
+  ];
+  delete _data.runtimeConfig;
+  importData.push(`export const cliConfigs: Partial<SilgiRuntimeOptions & SilgiOptions> = ${genObjectFromRawEntries(
+    Object.entries(_data).map(
+      ([key, value]) => [key, genEnsureSafeVar(value)]
+    ).concat(
+      [
+        ["runtimeConfig", "runtime"]
+      ]
+    )
+  )}`);
+  return importData;
+}
+
+export { prepareConfigs };

package/dist/cli/scan/prepareCoreFile.mjs

@@ -0,0 +1,166 @@
+import { hash } from 'silgi/kit';
+
+async function prepareCoreFile(data, frameworkContext, silgi) {
+  let importItems = {
+    "silgi": {
+      import: [
+        {
+          name: "createSilgi",
+          key: "createSilgi"
+        }
+      ],
+      from: "silgi"
+    },
+    "silgi/types": {
+      import: [
+        {
+          name: "SilgiRuntimeOptions",
+          type: true,
+          key: "SilgiRuntimeOptions"
+        },
+        {
+          name: "FrameworkContext",
+          type: true,
+          key: "FrameworkContext"
+        },
+        {
+          name: "SilgiOptions",
+          type: true,
+          key: "SilgiOptions"
+        }
+      ],
+      from: "silgi/types"
+    },
+    "#silgi/vfs": {
+      import: [],
+      from: "./vfs"
+    },
+    "scan.ts": {
+      import: [
+        {
+          name: "uris",
+          type: false,
+          key: "uris"
+        },
+        {
+          name: "services",
+          type: false,
+          key: "services"
+        },
+        {
+          name: "shareds",
+          type: false,
+          key: "shareds"
+        },
+        {
+          name: "schemas",
+          type: false,
+          key: "schemas"
+        },
+        {
+          name: "modulesURIs",
+          type: false,
+          key: "modulesURIs"
+        }
+      ],
+      from: "./scan.ts"
+    },
+    "configs.ts": {
+      import: [
+        {
+          name: "cliConfigs",
+          type: false,
+          key: "cliConfigs"
+        }
+      ],
+      from: "./configs.ts"
+    },
+    "rules.ts": {
+      import: [
+        {
+          name: "routeRules",
+          key: "routeRules"
+        }
+      ],
+      from: "./rules.ts"
+    }
+  };
+  importItems = { ...data._importItems, ...importItems };
+  const _data = {
+    customImports: data._customImports || [],
+    buildSilgiExtraContent: [],
+    beforeBuildSilgiExtraContent: [],
+    afterCliOptions: [],
+    _silgiConfigs: [],
+    customContent: [],
+    importItems
+  };
+  await silgi.callHook("prepare:core.ts", _data);
+  if (importItems["#silgi/vfs"].import.length === 0) {
+    delete importItems["#silgi/vfs"];
+  }
+  const plugins = [];
+  for (const plugin of silgi.options.plugins) {
+    const pluginImportName = `_${hash(plugin.packageImport)}`;
+    _data.customImports.push(`import ${pluginImportName} from '${plugin.packageImport}'`);
+    plugins.push(pluginImportName);
+  }
+  const importsContent = [
+    'import deepmerge from "@fastify/deepmerge"',
+    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
+      if (silgi.options.typescript.removeFileExtension) {
+        from = from.replace(/\.(js|ts|mjs|cjs|jsx|tsx)$/, "");
+      }
+      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${from}'`;
+    }),
+    "",
+    ..._data.customImports,
+    ""
+  ];
+  const importData = [
+    "",
+    "const mergeDeep = deepmerge({all: true})",
+    "",
+    "export async function buildSilgi(framework: FrameworkContext, moduleOptions?: Partial<SilgiRuntimeOptions>,buildOptions?: Partial<SilgiOptions>) {",
+    "",
+    _data.beforeBuildSilgiExtraContent.length > 0 ? _data.beforeBuildSilgiExtraContent.map(({ value, type }) => {
+      return type === "function" ? value : `const ${value}`;
+    }) : "",
+    "",
+    "  const silgi = await createSilgi({",
+    "      framework,",
+    "      shared: shareds as any,",
+    "      services: services as any,",
+    "      schemas: schemas as any,",
+    "      uris,",
+    "      modulesURIs,",
+    `      plugins: [${plugins.join(", ")}],`,
+    _data._silgiConfigs.length > 0 ? `      ${_data._silgiConfigs.map((config) => typeof config === "string" ? config : typeof config === "object" ? Object.entries(config).map(([key, value]) => `${key}: ${value}`).join(",\n      ") : "").join(",\n      ")},` : "",
+    "      options: mergeDeep(",
+    "        {",
+    "        runtimeConfig: {} as SilgiRuntimeOptions,",
+    "        routeRules: routeRules as any,",
+    "        },",
+    "        moduleOptions || {},",
+    "        {",
+    `          present: '${silgi.options.preset}',`,
+    "          ...cliConfigs,",
+    "        },",
+    "        buildOptions,",
+    "      ) as any,",
+    "    })",
+    "",
+    ...frameworkContext,
+    "",
+    ..._data.buildSilgiExtraContent,
+    "",
+    "  return silgi",
+    "}",
+    ""
+  ];
+  await silgi.callHook("after:prepare:core.ts", importData);
+  importData.unshift(...importsContent);
+  return importData;
+}
+
+export { prepareCoreFile };

package/dist/cli/scan/prepareFramework.mjs

@@ -0,0 +1,73 @@
+import { isAbsolute } from 'pathe';
+import { relativeWithDot } from 'silgi/kit';
+
+async function prepareFramework(silgi) {
+  const importItems = {
+    "silgi/types": {
+      import: [
+        {
+          name: "SilgiRuntimeContext",
+          type: true,
+          key: "SilgiRuntimeContext"
+        }
+      ],
+      from: "silgi/types"
+    }
+  };
+  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 importItems = {
+    "silgi/types": {
+      import: [
+        {
+          name: "SilgiRuntimeContext",
+          type: true,
+          key: "SilgiRuntimeContext"
+        }
+      ],
+      from: "silgi/types"
+    }
+  };
+  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;
+      if (silgi.options.typescript.removeFileExtension) {
+        from = from.replace(/\.(js|ts|mjs|cjs|jsx|tsx)$/, "");
+      }
+      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
+    }),
+    "",
+    ...customImports,
+    "",
+    ...customContent,
+    ""
+  ];
+  return {
+    content,
+    importItems
+  };
+}
+
+export { createDTSFramework, prepareFramework };