silgi 0.24.15 → 0.24.17

package/dist/kit/module.mjs

@@ -0,0 +1,73 @@
+import { defu } from 'defu';
+import { tryUseSilgiCLI, useSilgiCLI } from 'silgi';
+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 = typeof module.defaults === "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.options.isPreparingModules) {
+      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/parseServices.mjs

@@ -0,0 +1,57 @@
+import { defu } from 'defu';
+import { withLeadingSlash } from 'ufo';
+
+function serviceParseModule(params) {
+  return params;
+}
+const parseRouteRules = serviceParseModule(({
+  node,
+  basePath,
+  silgi,
+  pathLength
+}) => {
+  const routeRules = node.routeRules;
+  if (!routeRules)
+    return;
+  let removeMethod = "";
+  removeMethod = withLeadingSlash(basePath);
+  if (pathLength === 1 || pathLength === 2 || pathLength === 3) {
+    if (routeRules.doubleSplat === void 0) {
+      routeRules.doubleSplat = true;
+    }
+  }
+  if (routeRules.splat)
+    removeMethod = `${removeMethod}/*`;
+  else if (routeRules.doubleSplat)
+    removeMethod = `${removeMethod}/**`;
+  removeMethod = removeMethod.replace(/\/{2,}/g, "/");
+  delete routeRules.splat;
+  delete routeRules.doubleSplat;
+  silgi.routeRules.addRule(removeMethod, routeRules);
+});
+function parseServices(silgi, pathLength = [4, 3, 2, 1], servicesObject, currentPath = []) {
+  const modulesURIs = {};
+  silgi.options.serviceParseModules.push(parseRouteRules);
+  const pathLengths = Array.isArray(pathLength) ? pathLength : [pathLength];
+  function traverse(node, path = []) {
+    if (!node || typeof node !== "object")
+      return;
+    if (pathLengths.includes(path.length)) {
+      const basePath = path.join("/");
+      for (const handler of silgi.options.serviceParseModules) {
+        handler({ node, basePath, silgi, modulesURIs, pathLength: path.length });
+      }
+    }
+    for (const key in node) {
+      if (!["_type", "fields"].includes(key)) {
+        traverse(node[key], [...path, key]);
+      }
+    }
+  }
+  traverse(servicesObject || silgi.services, currentPath);
+  silgi.options.serviceParseModules = [];
+  silgi.modulesURIs = defu(modulesURIs, silgi.modulesURIs);
+  return modulesURIs;
+}
+
+export { parseRouteRules, parseServices, serviceParseModule };

package/dist/kit/path.mjs

@@ -0,0 +1,34 @@
+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

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

package/dist/kit/resolve.mjs

@@ -0,0 +1,80 @@
+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';
+import { tryUseSilgiCLI } from 'silgi';
+
+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) {
+  alias ||= tryUseSilgiCLI()?.options.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

@@ -0,0 +1,49 @@
+import { existsSync } from 'node:fs';
+import { parse, basename, resolve } from 'pathe';
+import { useSilgiCLI } from 'silgi';
+import { hash } from 'silgi/kit';
+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) {
+    const silgi = useSilgiCLI();
+    const dir = template.where === ".silgi" ? silgi.options.build.dir : template.where === "server" ? silgi.options.silgi.serverDir : template.where === "client" ? silgi.options.silgi.clientDir : silgi.options.silgi.serverDir;
+    template.dst = resolve(buildDir ?? dir, template.filename);
+  }
+  return template;
+}
+
+export { addTemplate, normalizeTemplate };

package/dist/kit/useRequest.mjs

@@ -0,0 +1,91 @@
+import { useSilgi } from 'silgi';
+
+function useRequest(event) {
+  const silgi = useSilgi();
+  if (silgi.options.present === "nuxt" || silgi.options.present === "nitro" || silgi.options.present === "h3") {
+    return event.node.req;
+  }
+  return event;
+}
+function useResponse(event) {
+  const silgi = useSilgi();
+  if (silgi.options.present === "nuxt" || silgi.options.present === "nitro" || silgi.options.present === "h3") {
+    return event.node.res;
+  }
+  return event;
+}
+function getIpAddress(event) {
+  const silgi = useSilgi();
+  if (silgi.options.present === "nuxt" || silgi.options.present === "nitro" || silgi.options.present === "h3") {
+    const _ipAddress = ipAddress(event.node.req);
+    return _ipAddress;
+  }
+  return false;
+}
+function ipAddress(req) {
+  const headers = [
+    "cf-connecting-ip",
+    // Cloudflare
+    "true-client-ip",
+    // Akamai and Cloudflare
+    "x-real-ip",
+    // Nginx proxy/FastCGI
+    "x-forwarded-for",
+    // Standard proxy header
+    "x-client-ip",
+    // Apache
+    "x-forwarded",
+    // Alternative format
+    "forwarded",
+    // RFC 7239 compliant format
+    "forwarded-for",
+    // RFC 7239 variant
+    "x-appengine-user-ip",
+    // Google App Engine
+    "x-cluster-client-ip",
+    // GCP load balancer
+    "fastly-client-ip",
+    // Fastly CDN
+    "x-azure-clientip",
+    // Azure
+    "x-original-forwarded-for",
+    // Secondary forwarded-for header
+    "x-lb-forwarded-for",
+    // Load balancer specific
+    "cdn-loop"
+    // Used by some CDNs
+  ];
+  for (const header of headers) {
+    const value = req.headers[header];
+    if (!value)
+      continue;
+    let ip;
+    if (Array.isArray(value)) {
+      ip = value[0];
+    } else if (header === "x-forwarded-for" || header === "forwarded-for" || header === "x-original-forwarded-for") {
+      ip = value.split(",")[0];
+    } else if (header === "forwarded") {
+      const match = value.match(/for=([^;]+)/);
+      ip = match ? match[1].trim().replace(/^\[|\]$/g, "") : "";
+    } else {
+      ip = value;
+    }
+    const cleanIp = ip.trim();
+    if (cleanIp && isValidIp(cleanIp)) {
+      return cleanIp;
+    }
+  }
+  const socketIp = req.socket.remoteAddress ?? "";
+  return socketIp && isValidIp(socketIp) ? socketIp : "";
+}
+function isValidIp(ip) {
+  if (ip === "::1" || ip === "localhost" || ip === "127.0.0.1")
+    return true;
+  if (/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(ip))
+    return true;
+  if (/^[0-9a-f:]+$/i.test(ip))
+    return true;
+  return false;
+}
+
+export { getIpAddress, ipAddress, useRequest, useResponse };

package/dist/kit/utils.mjs

@@ -0,0 +1,43 @@
+import { relative } from 'pathe';
+import { useSilgiCLI } from 'silgi';
+
+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 hasSilgiModule(moduleKey, silgi = useSilgiCLI()) {
+  return silgi.scanModules.some(({ meta }) => meta.configKey === moduleKey) || Object.keys(silgi.scanModules).includes(moduleKey);
+}
+function hasInstalledModule(moduleKey, silgi = useSilgiCLI()) {
+  const find = silgi.scanModules.find(({ meta }) => meta.configKey === moduleKey);
+  return find?.installed ?? false;
+}
+const baseHeaderBannerComment = [
+  "// DO NOT EDIT THIS FILE",
+  "// This file is generated by Silgi",
+  "/* eslint-disable */",
+  "/* prettier-ignore */",
+  "/* tslint:disable */"
+];
+function processFilePath(src) {
+  const silgi = useSilgiCLI();
+  if (silgi.options.typescript.removeFileExtension) {
+    src = src.replace(/\.ts$/, "");
+    return src;
+  }
+  return src;
+}
+
+export { MODE_RE, baseHeaderBannerComment, filterInPlace, hasInstalledModule, hasSilgiModule, processFilePath, relativeWithDot, toArray };

package/dist/package.json.mjs

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

package/dist/types/index.d.mts

@@ -578,7 +578,7 @@ interface SilgiCLIOptions extends PresetOptions {
     commandType: CommandType;
     routeRules: SilgiRouteRules$1;
     environments: DotenvOptions$1[];
-    activeEnvironment: string;
+    activeEnvironment: 'dev' | 'docker' | 'staging' | 'testing' | '.env' | (string & {});
     envOptions: EnvOptions$1;
     runtimeConfig: SilgiRuntimeConfig$1 & {
         [key: string]: any;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.24.15",
+  "version": "0.24.17",
   "private": false,
   "sideEffects": false,
   "exports": {