silgi 0.24.15 → 0.24.17

package/dist/core/unctx.mjs

@@ -0,0 +1,27 @@
+import { getContext } from 'unctx';
+
+const silgiCtx = getContext("silgi");
+function useSilgi() {
+  const instance = silgiCtx.tryUse();
+  if (!instance) {
+    throw new Error("Silgi instance is unavailable!");
+  }
+  return instance;
+}
+function normalizeResult(result) {
+  if (Array.isArray(result)) {
+    return [...result];
+  }
+  if (result && typeof result === "object") {
+    if (Object.keys(result).every((key) => !Number.isNaN(Number(key)))) {
+      return Object.values(result);
+    }
+    return { ...result };
+  }
+  return result;
+}
+function tryUseSilgi() {
+  return silgiCtx.tryUse();
+}
+
+export { normalizeResult, silgiCtx, tryUseSilgi, useSilgi };

package/dist/core/uris/uri.mjs

@@ -0,0 +1,33 @@
+import { parseURI } from './utils.mjs';
+
+async function findAction(silgi, uri) {
+  const { parts } = parseURI(uri, silgi.uris);
+  let result = silgi.services;
+  for (const part of parts) {
+    if (result && Object.prototype.hasOwnProperty.call(result, part)) {
+      result = Object.assign({}, result[part]);
+    } else {
+      silgi.logger.fail("Action not found:", `${parts.join("/")}`);
+      continue;
+    }
+  }
+  return result;
+}
+async function scanAction(silgi) {
+  for (const [key, _value] of Object.entries(silgi.uris)) {
+    const segments = key.split("/").filter(Boolean);
+    if (segments.length !== 4) {
+      console.error(`Invalid URI format for key "${key}". URI must have exactly 4 segments in format: namespace/service/method/action`);
+      continue;
+    }
+    const [namespace, service, method, action] = segments;
+    if (!namespace || !service || !method || !action) {
+      console.error(`Invalid URI segments for key "${key}". All segments must be non-empty`);
+      continue;
+    }
+    const handler = await findAction(silgi, key);
+    silgi.scannedHandlers.set(key, handler);
+  }
+}
+
+export { findAction, scanAction };

package/dist/core/uris/utils.mjs

@@ -0,0 +1,130 @@
+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
+        }
+      });
+    }
+    if (query && query.method) {
+      delete query.method;
+    }
+    return {
+      namespaceName,
+      serviceName,
+      methodName,
+      actionName,
+      raw: normalizedUri,
+      parts: [namespaceName, serviceName, methodName, actionName],
+      routerParams: {},
+      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

@@ -0,0 +1,15 @@
+import { useSilgi } from '../unctx.mjs';
+
+function getEvent(event) {
+  const silgi = useSilgi();
+  if (silgi.options.present === "h3" || silgi.options.present === "nitro" || silgi.options.present === "nuxt") {
+    return event.event;
+  }
+  return event;
+}
+function getEventContext(event) {
+  const _event = getEvent(event);
+  return _event.context;
+}
+
+export { getEvent, getEventContext };

package/dist/core/utils/merge.mjs

@@ -0,0 +1,29 @@
+function merge(items, maxLevel = 4, currentLevel = 1) {
+  const arrayItems = Array.isArray(items) ? items : [items];
+  return arrayItems.reduce((acc, item) => {
+    if (!item)
+      return acc;
+    Object.keys(item).forEach((key) => {
+      if (typeof item[key] === "object" && item[key] !== null && currentLevel < maxLevel) {
+        if (!acc[key] || typeof acc[key] !== "object") {
+          acc[key] = {};
+        }
+        acc[key] = merge([acc[key], item[key]], maxLevel, currentLevel + 1);
+      } else if (acc[key] === void 0) {
+        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/runtime.mjs

@@ -0,0 +1,22 @@
+function replaceRuntimeValues(obj, runtime) {
+  if (!obj || typeof obj !== "object")
+    return obj;
+  for (const key in obj) {
+    if (typeof obj[key] === "string" && obj[key].startsWith("runtime.")) {
+      const runtimePath = obj[key].substring(8).split(".");
+      let value = runtime;
+      for (const segment of runtimePath) {
+        if (value === void 0 || value === null)
+          break;
+        value = value[segment];
+      }
+      if (value !== void 0)
+        obj[key] = value;
+    } else if (typeof obj[key] === "object" && obj[key] !== null) {
+      obj[key] = replaceRuntimeValues(obj[key], runtime);
+    }
+  }
+  return obj;
+}
+
+export { replaceRuntimeValues };

package/dist/core/utils/schema.mjs

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

package/dist/core/utils/service.mjs

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

package/dist/core/utils/shared.mjs

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

package/dist/core/utils/storage.mjs

@@ -0,0 +1,72 @@
+import { Buffer } from 'node:buffer';
+import { klona } from 'klona';
+import { useSilgiRuntimeConfig } from 'silgi/runtime';
+import { createStorage as createStorage$1, builtinDrivers, prefixStorage } from 'unstorage';
+import { ErrorFactory, HttpStatus } from '../error.mjs';
+import { useSilgi } from '../unctx.mjs';
+import { replaceRuntimeValues } from './runtime.mjs';
+
+async function createStorage(silgi) {
+  const storage = createStorage$1();
+  const runtime = useSilgiRuntimeConfig();
+  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);
+      const processedOpts = replaceRuntimeValues({ ...opts }, runtime);
+      storage.mount(path, driver(processedOpts));
+    } 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 };