silgi 0.7.1 → 0.7.2

package/dist/core/uris/utils.mjs

@@ -1,127 +0,0 @@
-import { ErrorFactory, HttpStatus } from '../error.mjs';
-
-function parseURI(uri, uris) {
-  if (!uri) {
-    throw ErrorFactory.create({
-      message: "URI cannot be empty",
-      httpStatus: HttpStatus.BAD_REQUEST,
-      context: { uri }
-    });
-  }
-  if (!uris) {
-    throw ErrorFactory.create({
-      message: "URIs configuration is not provided",
-      httpStatus: HttpStatus.INTERNAL_SERVER_ERROR,
-      context: { uri }
-    });
-  }
-  const cleanUri = uri.replace(/^\/*(srn\/)?/, "").replace(/\/*$/, "");
-  const [path, queryString] = cleanUri.split("?");
-  const parts = path.split("/");
-  const query = queryString ? Object.fromEntries(
-    queryString.split("&").map((param) => param.split("="))
-  ) : void 0;
-  const method = query?.method ? query?.method.toLowerCase() : void 0;
-  const namespaceName = parts[0];
-  const serviceName = parts[1];
-  const methodName = method || parts[2];
-  const actionName = method ? parts[2] : parts[3];
-  if (!namespaceName || !serviceName || !methodName || !actionName) {
-    throw ErrorFactory.create({
-      message: "Invalid URI format: Insufficient path segments",
-      httpStatus: HttpStatus.BAD_REQUEST,
-      context: {
-        uri,
-        cleanUri,
-        partsLength: parts.length,
-        method,
-        namespaceName,
-        serviceName,
-        methodName,
-        actionName
-      }
-    });
-  }
-  const baseUri = `${namespaceName}/${serviceName}/${methodName}/${actionName}`;
-  const paramStartIndex = method ? 3 : 4;
-  const parameters = parts.slice(paramStartIndex);
-  const normalizedUri = method ? `${namespaceName}/${serviceName}/${method}/${actionName}${parameters.length ? `/${parameters.join("/")}` : ""}` : cleanUri;
-  const template = uris[baseUri];
-  if (template === void 0) {
-    throw ErrorFactory.create({
-      message: "No route found for URI",
-      httpStatus: HttpStatus.NOT_FOUND,
-      context: {
-        uri,
-        baseUri
-      }
-    });
-  }
-  if (template === "") {
-    if (parameters.length > 0) {
-      throw ErrorFactory.create({
-        message: "No parameters expected for this route",
-        httpStatus: HttpStatus.BAD_REQUEST,
-        context: {
-          uri,
-          baseUri,
-          extraParams: parameters
-        }
-      });
-    }
-    return {
-      namespaceName,
-      serviceName,
-      methodName,
-      actionName,
-      raw: normalizedUri,
-      parts: [namespaceName, serviceName, methodName, actionName],
-      routerParams: {},
-      query: method ? void 0 : query,
-      uri: baseUri
-    };
-  }
-  const routeTemplate = typeof template === "string" ? template : template.pattern;
-  const validators = typeof template === "string" ? void 0 : template.validators;
-  const routerParams = {};
-  const templateParts = routeTemplate.split("/").filter(Boolean);
-  const paramValues = parameters;
-  let valueIndex = 0;
-  templateParts.forEach((part) => {
-    if (part.startsWith(":")) {
-      const paramName = part.substring(1);
-      const paramValue = paramValues[valueIndex];
-      if (validators?.[paramName] && paramValue) {
-        if (!validators[paramName](paramValue)) {
-          throw ErrorFactory.create({
-            message: "Invalid value for parameter",
-            httpStatus: HttpStatus.UNPROCESSABLE_ENTITY,
-            context: {
-              uri,
-              paramName,
-              paramValue,
-              validatorName: paramName
-            }
-          });
-        }
-      }
-      routerParams[paramName] = paramValue || void 0;
-      valueIndex++;
-    } else if (part && part === paramValues[valueIndex]) {
-      valueIndex++;
-    }
-  });
-  return {
-    namespaceName,
-    serviceName,
-    methodName,
-    actionName,
-    raw: normalizedUri,
-    parts: [namespaceName, serviceName, methodName, actionName],
-    routerParams,
-    query: method ? void 0 : query,
-    uri: baseUri
-  };
-}
-
-export { parseURI };

package/dist/core/utils/event.mjs

@@ -1,5 +0,0 @@
-function getEvent(event) {
-  return event.event || event || {};
-}
-
-export { getEvent };

package/dist/core/utils/global.mjs

@@ -1,12 +0,0 @@
-import { lstatSync } from 'node:fs';
-import { dirname, isAbsolute } from 'pathe';
-
-function getDirectory(p) {
-  try {
-    return isAbsolute(p) && lstatSync(p).isFile() ? dirname(p) : p;
-  } catch {
-  }
-  return p;
-}
-
-export { getDirectory };

package/dist/core/utils/merge.mjs

@@ -1,25 +0,0 @@
-function merge(items, maxLevel = 4, currentLevel = 3) {
-  const arrayItems = Array.isArray(items) ? items : [items];
-  return arrayItems.reduce((acc, item) => {
-    Object.keys(item).forEach((key) => {
-      if (typeof item[key] === "object" && item[key] !== null && currentLevel < maxLevel) {
-        acc[key] = acc[key] || {};
-        acc[key] = merge([acc[key], item[key]], maxLevel, currentLevel + 1);
-      } else {
-        acc[key] = item[key];
-      }
-    });
-    return acc;
-  }, {});
-}
-function mergeSchemas(typesOrArray) {
-  return merge(typesOrArray);
-}
-function mergeServices(servicesOrArray) {
-  return merge(servicesOrArray);
-}
-function mergeShared(sharedOrArray) {
-  return merge(sharedOrArray, 1, 1);
-}
-
-export { mergeSchemas, mergeServices, mergeShared };

package/dist/core/utils/schema.mjs

@@ -1,5 +0,0 @@
-function createSchema(silgiType) {
-  return silgiType;
-}
-
-export { createSchema };

package/dist/core/utils/service.mjs

@@ -1,5 +0,0 @@
-function createService(variables) {
-  return variables;
-}
-
-export { createService };

package/dist/core/utils/shared.mjs

@@ -1,5 +0,0 @@
-function createShared(shared) {
-  return shared;
-}
-
-export { createShared };

package/dist/core/utils/storage.mjs

@@ -1,70 +0,0 @@
-import { Buffer } from 'node:buffer';
-import { klona } from 'klona';
-import { createStorage as createStorage$1, builtinDrivers, prefixStorage } from 'unstorage';
-import memoryDriver from 'unstorage/drivers/memory';
-import { ErrorFactory, HttpStatus } from '../error.mjs';
-import { useSilgi } from '../unctx.mjs';
-
-async function createStorage(silgi) {
-  const storage = createStorage$1();
-  const mounts = klona({
-    ...silgi.options.storage,
-    ...silgi.options.devStorage
-  });
-  for (const [path, opts] of Object.entries(mounts)) {
-    if (opts.driver) {
-      const driver = await import(builtinDrivers[opts.driver] || opts.driver).then((r) => r.default || r);
-      storage.mount("/memory:cache", memoryDriver());
-      storage.mount(path, driver(opts));
-    } else {
-      silgi.logger.warn(`No \`driver\` set for storage mount point "${path}".`);
-    }
-  }
-  return storage;
-}
-function useSilgiStorage(base = "/memory:cache") {
-  const silgi = useSilgi();
-  return base ? prefixStorage(silgi.storage, base) : silgi.storage;
-}
-async function generateStorageKey(params) {
-  const {
-    operation,
-    input,
-    keyGenerator,
-    requestId,
-    storageOptions
-  } = params;
-  const cacheScopePrefix = storageOptions?.scope === "request" ? "req" : "global";
-  const parts = [
-    cacheScopePrefix,
-    // Always include scope prefix first
-    operation.namespaceName,
-    operation.serviceName,
-    operation.methodName
-  ].filter(Boolean);
-  if (storageOptions?.scope === "request") {
-    if (!requestId) {
-      throw ErrorFactory.create({
-        code: HttpStatus.BAD_REQUEST,
-        message: "Request ID is required for request-scoped cache",
-        context: {
-          requestId,
-          operation,
-          input,
-          storageOptions,
-          keyGenerator
-        }
-      });
-    }
-    parts.push(requestId);
-  }
-  if (keyGenerator) {
-    const customKey = await Promise.resolve(keyGenerator(input));
-    parts.push(customKey);
-  } else {
-    parts.push(typeof input === "object" ? JSON.stringify(input) : String(input));
-  }
-  return Buffer.from(parts.join(":")).toString("base64");
-}
-
-export { createStorage, generateStorageKey, useSilgiStorage };

package/dist/ecosystem/nitro/module.mjs

@@ -1,62 +0,0 @@
-import { execSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { resolve, dirname, join } from 'pathe';
-import { loadOptions } from 'silgi/core';
-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/kit/esm.mjs

@@ -1,10 +0,0 @@
-import { resolvePath } from 'mlly';
-
-async function tryResolveModule(id, url = import.meta.url) {
-  try {
-    return await resolvePath(id, { url });
-  } catch {
-  }
-}
-
-export { tryResolveModule };

package/dist/kit/fs.mjs

@@ -1,25 +0,0 @@
-import fsp from 'node:fs/promises';
-import { consola } from 'consola';
-import { dirname } from 'pathe';
-import { prettyPath } from './path.mjs';
-
-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.info("Generated", prettyPath(file));
-  }
-}
-async function isDirectory(path) {
-  try {
-    return (await fsp.stat(path)).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-export { isDirectory, writeFile };

package/dist/kit/isFramework.mjs

@@ -1,25 +0,0 @@
-import { useSilgi } from 'silgi/core';
-
-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;
-}
-
-export { isH3, isNitro, isNuxt };

package/dist/kit/logger.mjs

@@ -1,8 +0,0 @@
-import { consola } from 'consola';
-
-const logger = consola;
-function useLogger(tag, options = {}) {
-  return tag ? logger.create(options).withTag(tag) : logger;
-}
-
-export { logger, useLogger };

package/dist/kit/module.mjs

@@ -1,73 +0,0 @@
-import { defu } from 'defu';
-import { tryUseSilgiCLI, useSilgiCLI } from 'silgi/core';
-import { checkSilgiCompatibility } from '../cli/utils/compatibility.mjs';
-
-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;
-}
-
-export { _defineSilgiModule, defineSilgiModule };

package/dist/kit/path.mjs

@@ -1,34 +0,0 @@
-import consola from 'consola';
-import { colors } from 'consola/utils';
-import { getProperty } from 'dot-prop';
-import { relative, resolve } from 'pathe';
-
-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 { prettyPath, resolveSilgiPath };

package/dist/kit/preset.mjs

@@ -1,6 +0,0 @@
-function defineSilgiPreset(preset, meta) {
-  if (meta?.url && typeof preset !== "function") ;
-  return { ...preset, _meta: meta };
-}
-
-export { defineSilgiPreset };

package/dist/kit/resolve.mjs

@@ -1,78 +0,0 @@
-import { existsSync, promises } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { resolvePath as resolvePath$1 } from 'mlly';
-import { dirname, resolve, normalize, isAbsolute, join } from 'pathe';
-import { resolveAlias as resolveAlias$1 } from 'pathe/utils';
-
-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;
-}
-
-export { createResolver, resolveAlias, resolvePath, resolveSilgiModule };

package/dist/kit/template.mjs

@@ -1,47 +0,0 @@
-import { existsSync } from 'node:fs';
-import { hash } from 'ohash';
-import { parse, basename, resolve } from 'pathe';
-import { useSilgiCLI } from 'silgi/core';
-import { filterInPlace } from './utils.mjs';
-
-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 { addTemplate, normalizeTemplate };

package/dist/kit/utils.mjs

@@ -1,20 +0,0 @@
-import { relative } from 'pathe';
-
-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+)*$/;
-
-export { MODE_RE, filterInPlace, relativeWithDot, toArray };

package/dist/package.json.mjs

@@ -1,5 +0,0 @@
-const version = "0.7.1";
-const packageJson = {
-	version: version};
-
-export { packageJson as default, version };