silgi 0.7.0 → 0.7.1

package/dist/core/config/resolvers/paths.mjs

@@ -0,0 +1,194 @@
+import { existsSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import { resolvePath as resolvePath$1 } from 'mlly';
+import { resolve, join, isAbsolute } from 'pathe';
+import { findWorkspaceDir, readPackageJSON } from 'pkg-types';
+import { resolveSilgiPath, resolveAlias, resolvePath } from 'silgi/kit';
+import { runtimeDir, pkgDir } from 'silgi/runtime/meta';
+import { isRelative } from 'ufo';
+import { SilgiCLIDefaults } from '../defaults.mjs';
+
+async function resolvePathOptions(options) {
+  options.rootDir = resolve(options.rootDir || ".");
+  options.workspaceDir = await findWorkspaceDir(options.rootDir).catch(
+    () => options.rootDir
+  );
+  options.srcDir = resolve(options.srcDir || options.rootDir);
+  for (const key of ["srcDir"]) {
+    options[key] = resolve(options.rootDir, options[key]);
+  }
+  options.build.dir = resolve(options.rootDir, options.build.dir);
+  options.build.typesDir = resolveSilgiPath(
+    options.build.typesDir || SilgiCLIDefaults.build.typesDir,
+    options,
+    options.rootDir
+  );
+  if (options.preset === "npm-package") {
+    const packageJsonPath = resolve(options.rootDir, "package.json");
+    const packageJson = await readPackageJSON(packageJsonPath);
+    if (packageJson.name === void 0) {
+      throw new Error("Package name is undefined");
+    }
+    options.alias ||= {};
+    options.alias[packageJson.name] = join(options.rootDir, "src/module.ts");
+    options.alias[`${packageJson.name}/runtime/`] = join(options.rootDir, "src/runtime/");
+  }
+  if (options.typescript?.internalPaths || options.stub) {
+    options.alias = {
+      ...options.alias,
+      "silgi/runtime": join(runtimeDir),
+      "#internal/silgi": join(runtimeDir),
+      "silgi/runtime/*": join(runtimeDir, "*"),
+      "#internal/silgi/*": join(runtimeDir, "*")
+    };
+    options.typescript.customConditions = [
+      ...options.typescript.customConditions,
+      "silgiTypes"
+    ];
+    options.conditions ||= [];
+    options.conditions.push("silgi");
+  }
+  options.alias = {
+    ...options.alias,
+    "~/": join(options.srcDir, "/"),
+    "@/": join(options.srcDir, "/"),
+    "~~/": join(options.rootDir, "/"),
+    "@@/": join(options.rootDir, "/")
+  };
+  if (options.preset === "npm-package") {
+    options.alias = {
+      ...options.alias,
+      "#silgi/app/": join(options.build.dir, "/")
+    };
+  }
+  if (options.alias && typeof options.alias === "object") {
+    ((options.typescript.tsConfig ??= {}).compilerOptions ??= {}).paths ??= {};
+    const paths = options.typescript.tsConfig.compilerOptions.paths;
+    for (const [key, value] of Object.entries(options.alias)) {
+      if (typeof paths === "object") {
+        paths[key] = [value];
+      }
+    }
+  }
+  if (options.typescript.tsConfig.compilerOptions?.paths && typeof options.typescript.tsConfig.compilerOptions.paths === "object") {
+    ((options.typescript.tsConfig ??= {}).compilerOptions ??= {}).paths ??= {};
+    const paths = options.typescript.tsConfig.compilerOptions.paths;
+    for (const [key, value] of Object.entries(options.alias)) {
+      if (typeof paths === "object") {
+        paths[key] = [value];
+      }
+    }
+  }
+  options.modulesDir = [resolve(options.rootDir, "node_modules")];
+  options.output.dir = resolveSilgiPath(
+    options.output.dir || SilgiCLIDefaults.output.dir,
+    options,
+    options.rootDir
+  );
+  options.output.publicDir = resolveSilgiPath(
+    options.output.publicDir || SilgiCLIDefaults.output.publicDir,
+    options,
+    options.rootDir
+  );
+  options.output.serverDir = resolveSilgiPath(
+    options.output.serverDir || SilgiCLIDefaults.output.serverDir,
+    options,
+    options.rootDir
+  );
+  options.serverDir = resolveSilgiPath(
+    options.serverDir || SilgiCLIDefaults.serverDir,
+    options,
+    options.rootDir
+  );
+  options.clientDir = resolveSilgiPath(
+    options.clientDir || SilgiCLIDefaults.clientDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.serverDir = resolveSilgiPath(
+    options.silgi.serverDir || SilgiCLIDefaults.silgi.serverDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.clientDir = resolveSilgiPath(
+    options.silgi.clientDir || SilgiCLIDefaults.silgi.clientDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.publicDir = resolveSilgiPath(
+    options.silgi.publicDir || SilgiCLIDefaults.silgi.publicDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.utilsDir = resolveSilgiPath(
+    options.silgi.utilsDir || SilgiCLIDefaults.silgi.utilsDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.vfsDir = resolveSilgiPath(
+    options.silgi.vfsDir || SilgiCLIDefaults.silgi.vfsDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.typesDir = resolveSilgiPath(
+    options.silgi.typesDir || SilgiCLIDefaults.silgi.typesDir,
+    options,
+    options.rootDir
+  );
+  options.nodeModulesDirs.push(resolve(options.workspaceDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(options.rootDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(pkgDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(pkgDir, ".."));
+  options.nodeModulesDirs = [
+    ...new Set(
+      options.nodeModulesDirs.map((dir) => resolve(options.rootDir, dir))
+    )
+  ];
+  options.scanDirs.unshift(options.srcDir);
+  options.scanDirs = options.scanDirs.map(
+    (dir) => resolve(options.srcDir, dir)
+  );
+  options.scanDirs = [...new Set(options.scanDirs)];
+  options.appConfigFiles ??= [];
+  options.appConfigFiles = options.appConfigFiles.map((file) => _tryResolve(resolveSilgiPath(file, options))).filter(Boolean);
+  for (const dir of options.scanDirs) {
+    const configFile = _tryResolve("app.config", dir);
+    if (configFile && !options.appConfigFiles.includes(configFile)) {
+      options.appConfigFiles.push(configFile);
+    }
+  }
+  const modulesRuntimePaths = {};
+  if (options.typescript?.internalPaths) {
+    for (let i of options.modules) {
+      if (typeof i === "string") {
+        i = resolveAlias(i, options.alias);
+        if (isRelative(i)) {
+          i = resolve(options.rootDir, i);
+        }
+        const src = isAbsolute(i) ? pathToFileURL(await resolvePath(i, { fallbackToOriginal: false, extensions: options.extensions })).href : await resolvePath$1(i, { url: options.modulesDir.map((m) => pathToFileURL(m.replace(/\/node_modules\/?$/, ""))), extensions: options.extensions });
+        const cleanPath = src.replace(/(\/(?:src|dist)(?:\/runtime)?(?:\/.*)?$)/, "");
+        modulesRuntimePaths[`${i}/runtime`] = `${cleanPath}/src/runtime`;
+      }
+    }
+    for (const [key, value] of Object.entries(modulesRuntimePaths)) {
+      options.alias = {
+        ...options.alias,
+        [`${key}`]: value
+      };
+    }
+  }
+}
+function _tryResolve(path, base = ".", extensions = ["", ".js", ".ts", ".mjs", ".cjs", ".json"]) {
+  path = resolve(base, path);
+  if (existsSync(path)) {
+    return path;
+  }
+  for (const ext of extensions) {
+    const p = path + ext;
+    if (existsSync(p)) {
+      return p;
+    }
+  }
+}
+
+export { resolvePathOptions };

package/dist/core/config/resolvers/storage.mjs

@@ -0,0 +1,25 @@
+import { resolve } from 'pathe';
+
+async function resolveStorageOptions(options) {
+  const fsMounts = {
+    root: resolve(options.rootDir),
+    src: resolve(options.srcDir),
+    build: resolve(options.build.dir),
+    cache: resolve(options.build.dir, "cache")
+  };
+  for (const p in fsMounts) {
+    options.devStorage[p] = options.devStorage[p] || {
+      driver: "fs",
+      readOnly: p === "root" || p === "src",
+      base: fsMounts[p]
+    };
+  }
+  if (options.dev && options.storage.data === void 0 && options.devStorage.data === void 0) {
+    options.devStorage.data = {
+      driver: "fs",
+      base: resolve(options.rootDir, ".data/kv")
+    };
+  }
+}
+
+export { resolveStorageOptions };

package/dist/core/config/resolvers/url.mjs

@@ -0,0 +1,7 @@
+import { withLeadingSlash, withTrailingSlash } from 'ufo';
+
+async function resolveURLOptions(options) {
+  options.baseURL = withLeadingSlash(withTrailingSlash(options.baseURL));
+}
+
+export { resolveURLOptions };

package/dist/core/config/types.mjs

@@ -0,0 +1,160 @@
+import { promises } from 'node:fs';
+import { defu } from 'defu';
+import { resolve, dirname, join, isAbsolute, relative } from 'pathe';
+import { readPackageJSON } from 'pkg-types';
+import { relativeWithDot, resolveSilgiModule } from 'silgi/kit';
+import { withTrailingSlash } from 'ufo';
+import { getDirectory } from '../utils/global.mjs';
+
+function renderAttrs(obj) {
+  const attrs = [];
+  for (const key in obj) {
+    attrs.push(renderAttr(key, obj[key]));
+  }
+  return attrs.join(" ");
+}
+function renderAttr(key, value) {
+  return value ? `${key}="${value}"` : "";
+}
+async function silgiGenerateType(silgi) {
+  const rootDirWithSlash = withTrailingSlash(silgi.options.rootDir);
+  const tsConfigPath = resolve(
+    silgi.options.rootDir,
+    silgi.options.typescript.tsconfigPath
+  );
+  const tsconfigDir = dirname(tsConfigPath);
+  const include = /* @__PURE__ */ new Set([
+    relativeWithDot(tsconfigDir, join(silgi.options.build.typesDir, "silgi.d.ts")).replace(
+      /^(?=[^.])/,
+      "./"
+    ),
+    join(relativeWithDot(tsconfigDir, silgi.options.rootDir), "**/*"),
+    ...silgi.options.srcDir === silgi.options.rootDir ? [] : [join(relativeWithDot(tsconfigDir, silgi.options.srcDir), "**/*")]
+  ]);
+  const exclude = /* @__PURE__ */ new Set([
+    // nitro generate output: https://github.com/nuxt/nuxt/blob/main/packages/nuxt/src/core/nitro.ts#L186
+    relativeWithDot(silgi.options.build.dir, resolve(silgi.options.rootDir, "dist"))
+  ]);
+  for (const dir of silgi.options.modulesDir) {
+    exclude.add(relativeWithDot(silgi.options.build.dir, dir));
+  }
+  const moduleEntryPaths = [];
+  for (const m of silgi.scanModules) {
+    if (m.entryPath) {
+      moduleEntryPaths.push(getDirectory(m.entryPath));
+    }
+  }
+  const modulePaths = await resolveSilgiModule(rootDirWithSlash, moduleEntryPaths);
+  for (const path of modulePaths) {
+    const relative2 = relativeWithDot(silgi.options.build.dir, path);
+    include.add(join(relative2, "runtime"));
+    exclude.add(join(relative2, "runtime/server"));
+    include.add(join(relative2, "dist/runtime"));
+    exclude.add(join(relative2, "dist/runtime/server"));
+  }
+  const tsConfig = defu(silgi.options.typescript?.tsConfig, {
+    compilerOptions: {
+      forceConsistentCasingInFileNames: true,
+      strict: silgi.options.typescript.strict,
+      noEmit: true,
+      target: "ESNext",
+      module: "ESNext",
+      moduleResolution: "Bundler",
+      allowJs: true,
+      resolveJsonModule: true,
+      jsx: "preserve",
+      allowSyntheticDefaultImports: true,
+      jsxFactory: "h",
+      jsxFragmentFactory: "Fragment",
+      allowImportingTsExtensions: true,
+      ...silgi.options.typescript.customConditions ? { customConditions: ["silgiTypes"] } : {},
+      paths: {
+        "#silgiImports": [
+          relativeWithDot(tsconfigDir, join(silgi.options.build.typesDir, "silgi-imports"))
+        ],
+        ...silgi.scanModules.reduce((acc, m) => {
+          if (m.entryPath) {
+            acc[m.meta.name] = [relativeWithDot(tsconfigDir, m.entryPath)];
+          }
+          return acc;
+        }, {}),
+        ...silgi.scanModules.reduce((acc, m) => {
+          if (m.entryPath) {
+            const directory = getDirectory(m.entryPath);
+            acc[`${m.meta.name}/*`] = [`${relativeWithDot(tsconfigDir, directory)}/*`];
+          }
+          return acc;
+        }, {})
+        // ...(silgi.options.typescript?.internalPaths
+        //   ? {
+        //       'silgi/runtime': [
+        //         relativeWithDot(tsconfigDir, join(runtimeDir, 'index')),
+        //       ],
+        //       '#internal/silgi': [
+        //         relativeWithDot(tsconfigDir, join(runtimeDir, 'index')),
+        //       ],
+        //       'silgi/runtime/*': [
+        //         relativeWithDot(tsconfigDir, join(runtimeDir, '*')),
+        //       ],
+        //       '#internal/silgi/*': [
+        //         relativeWithDot(tsconfigDir, join(runtimeDir, '*')),
+        //       ],
+        //     }
+        //   : {}),
+      }
+    },
+    include: [...include],
+    exclude: [...exclude]
+  });
+  tsConfig.compilerOptions ||= {};
+  tsConfig.compilerOptions.paths ||= {};
+  tsConfig.include ||= [];
+  for (const alias in tsConfig.compilerOptions.paths) {
+    const paths = tsConfig.compilerOptions.paths[alias];
+    tsConfig.compilerOptions.paths[alias] = await Promise.all(
+      paths.map(async (path) => {
+        if (!isAbsolute(path)) {
+          return path;
+        }
+        const stats = await promises.stat(path).catch(
+          () => null
+          /* file does not exist */
+        );
+        return relativeWithDot(
+          tsconfigDir,
+          stats?.isFile() ? path.replace(/\b\.\w+$/g, "") : path
+        );
+      })
+    );
+  }
+  const references = [];
+  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);
+    references.push({ types: pkg?.name || id });
+  }));
+  const declarations = [];
+  await silgi.callHook("prepare:types", { references, declarations, tsConfig });
+  tsConfig.include = [...new Set(tsConfig.include.map((p) => isAbsolute(p) ? relativeWithDot(silgi.options.build.dir, p) : p))];
+  tsConfig.exclude = [...new Set(tsConfig.exclude.map((p) => isAbsolute(p) ? relativeWithDot(silgi.options.build.dir, p) : p))];
+  const _declarations = [
+    ...references.map((ref) => {
+      if ("path" in ref && isAbsolute(ref.path)) {
+        ref.path = relative(silgi.options.build.dir, ref.path);
+      }
+      return `/// <reference ${renderAttrs(ref)} />`;
+    }),
+    ...declarations,
+    "",
+    "export {}",
+    ""
+  ];
+  return {
+    declarations: _declarations,
+    tsConfig
+  };
+}
+
+export { silgiGenerateType };

package/dist/core/createSilgi.mjs

@@ -0,0 +1,84 @@
+import { createConsola } from 'consola';
+import defu from 'defu';
+import { isEvent } from 'h3';
+import { createHooks } from 'hookable';
+import { applyDefaults } from 'untyped';
+import { SilgiConfigSchema } from '../schema/index.mjs';
+import { silgiCtx } from './unctx.mjs';
+import { scanAction } from './uris/uri.mjs';
+import { createStorage, useSilgiStorage } from './utils/storage.mjs';
+
+async function runSilgiPlugins(silgi) {
+  for (const plugin of silgi.plugins) {
+    try {
+      await plugin(silgi);
+    } catch (error) {
+      silgi.captureError(error, { tags: ["plugin"] });
+      throw error;
+    }
+  }
+}
+async function createSilgi(config) {
+  const hooks = createHooks();
+  await applyDefaults(SilgiConfigSchema, config.options);
+  const silgi = {
+    schemas: config.schemas,
+    services: config.services ?? {},
+    shared: config.shared ?? void 0,
+    uris: config.uris ?? {},
+    modulesURIs: config.modulesURIs ?? {},
+    scannedHandlers: /* @__PURE__ */ new Map(),
+    plugins: config.plugins ?? [],
+    framework: config.framework ?? void 0,
+    storage: config.storage ?? void 0,
+    options: config.options,
+    hooks,
+    callHook: hooks.callHook,
+    addHooks: hooks.addHooks,
+    hook: hooks.hook,
+    ready: () => {
+      return hooks.callHook("ready", silgi);
+    },
+    close: () => hooks.callHook("close", silgi),
+    logger: createConsola(defu(config.options.consolaOptions, {
+      tag: "silgi"
+    })).withTag("silgi"),
+    captureError: (error, context = {}) => {
+      const promise = hooks.callHookParallel("error", error, context).catch((error_) => {
+        console.error("Error while capturing another error", error_);
+      });
+      if (context.event && isEvent(context.event)) {
+        const errors = context.event.context.nitro?.errors;
+        if (errors) {
+          errors.push({ error, context });
+        }
+        if (context.event.waitUntil) {
+          context.event.waitUntil(promise);
+        }
+      }
+    }
+  };
+  await runSilgiPlugins(silgi);
+  await scanAction(silgi);
+  if (!silgi.storage) {
+    silgi.storage = await createStorage(silgi);
+  }
+  silgi.shared.storage = (...data) => {
+    return useSilgiStorage(...data);
+  };
+  if (silgiCtx.tryUse()) {
+    silgiCtx.unset();
+    silgiCtx.set(silgi);
+  } else {
+    silgiCtx.set(silgi);
+    silgi.hook("close", () => silgiCtx.unset());
+  }
+  silgi.logger.info("Silgi installed");
+  hooks.hookOnce("close", async () => {
+    hooks.removeAllHooks();
+    await silgi.storage.dispose();
+  });
+  return silgi;
+}
+
+export { createSilgi };