silgi 0.24.19 → 0.24.21

package/dist/core/index.mjs

@@ -0,0 +1,763 @@
+import { createConsola } from 'consola';
+import defu, { defu as defu$1 } from 'defu';
+import { createHooks } from 'hookable';
+import { c as createRouteRules } from '../_chunks/silgiApp.mjs';
+export { s as silgiCLICtx, t as tryUseSilgiCLI, u as useSilgiCLI } from '../_chunks/silgiApp.mjs';
+import { getContext } from 'unctx';
+import { Buffer } from 'node:buffer';
+import { klona } from 'klona';
+import { useSilgiRuntimeConfig } from 'silgi/runtime';
+import { createStorage as createStorage$1, builtinDrivers, prefixStorage } from 'unstorage';
+import 'ufo';
+
+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();
+}
+
+var HttpStatus = /* @__PURE__ */ ((HttpStatus2) => {
+  HttpStatus2[HttpStatus2["CONTINUE"] = 100] = "CONTINUE";
+  HttpStatus2[HttpStatus2["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+  HttpStatus2[HttpStatus2["PROCESSING"] = 102] = "PROCESSING";
+  HttpStatus2[HttpStatus2["EARLY_HINTS"] = 103] = "EARLY_HINTS";
+  HttpStatus2[HttpStatus2["OK"] = 200] = "OK";
+  HttpStatus2[HttpStatus2["CREATED"] = 201] = "CREATED";
+  HttpStatus2[HttpStatus2["ACCEPTED"] = 202] = "ACCEPTED";
+  HttpStatus2[HttpStatus2["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+  HttpStatus2[HttpStatus2["NO_CONTENT"] = 204] = "NO_CONTENT";
+  HttpStatus2[HttpStatus2["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+  HttpStatus2[HttpStatus2["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+  HttpStatus2[HttpStatus2["MULTI_STATUS"] = 207] = "MULTI_STATUS";
+  HttpStatus2[HttpStatus2["ALREADY_REPORTED"] = 208] = "ALREADY_REPORTED";
+  HttpStatus2[HttpStatus2["IM_USED"] = 226] = "IM_USED";
+  HttpStatus2[HttpStatus2["MULTIPLE_CHOICES"] = 300] = "MULTIPLE_CHOICES";
+  HttpStatus2[HttpStatus2["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+  HttpStatus2[HttpStatus2["FOUND"] = 302] = "FOUND";
+  HttpStatus2[HttpStatus2["SEE_OTHER"] = 303] = "SEE_OTHER";
+  HttpStatus2[HttpStatus2["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+  HttpStatus2[HttpStatus2["USE_PROXY"] = 305] = "USE_PROXY";
+  HttpStatus2[HttpStatus2["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+  HttpStatus2[HttpStatus2["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+  HttpStatus2[HttpStatus2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+  HttpStatus2[HttpStatus2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+  HttpStatus2[HttpStatus2["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+  HttpStatus2[HttpStatus2["FORBIDDEN"] = 403] = "FORBIDDEN";
+  HttpStatus2[HttpStatus2["NOT_FOUND"] = 404] = "NOT_FOUND";
+  HttpStatus2[HttpStatus2["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+  HttpStatus2[HttpStatus2["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+  HttpStatus2[HttpStatus2["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+  HttpStatus2[HttpStatus2["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+  HttpStatus2[HttpStatus2["CONFLICT"] = 409] = "CONFLICT";
+  HttpStatus2[HttpStatus2["GONE"] = 410] = "GONE";
+  HttpStatus2[HttpStatus2["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+  HttpStatus2[HttpStatus2["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+  HttpStatus2[HttpStatus2["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+  HttpStatus2[HttpStatus2["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+  HttpStatus2[HttpStatus2["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+  HttpStatus2[HttpStatus2["RANGE_NOT_SATISFIABLE"] = 416] = "RANGE_NOT_SATISFIABLE";
+  HttpStatus2[HttpStatus2["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+  HttpStatus2[HttpStatus2["IM_A_TEAPOT"] = 418] = "IM_A_TEAPOT";
+  HttpStatus2[HttpStatus2["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
+  HttpStatus2[HttpStatus2["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+  HttpStatus2[HttpStatus2["LOCKED"] = 423] = "LOCKED";
+  HttpStatus2[HttpStatus2["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+  HttpStatus2[HttpStatus2["TOO_EARLY"] = 425] = "TOO_EARLY";
+  HttpStatus2[HttpStatus2["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
+  HttpStatus2[HttpStatus2["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+  HttpStatus2[HttpStatus2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+  HttpStatus2[HttpStatus2["REQUEST_HEADER_FIELDS_TOO_LARGE"] = 431] = "REQUEST_HEADER_FIELDS_TOO_LARGE";
+  HttpStatus2[HttpStatus2["UNAVAILABLE_FOR_LEGAL_REASONS"] = 451] = "UNAVAILABLE_FOR_LEGAL_REASONS";
+  HttpStatus2[HttpStatus2["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+  HttpStatus2[HttpStatus2["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+  HttpStatus2[HttpStatus2["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+  HttpStatus2[HttpStatus2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+  HttpStatus2[HttpStatus2["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+  HttpStatus2[HttpStatus2["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+  HttpStatus2[HttpStatus2["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
+  HttpStatus2[HttpStatus2["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
+  HttpStatus2[HttpStatus2["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
+  HttpStatus2[HttpStatus2["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
+  HttpStatus2[HttpStatus2["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
+  return HttpStatus2;
+})(HttpStatus || {});
+var ErrorSeverity = /* @__PURE__ */ ((ErrorSeverity2) => {
+  ErrorSeverity2["DEBUG"] = "DEBUG";
+  ErrorSeverity2["INFO"] = "INFO";
+  ErrorSeverity2["WARNING"] = "WARNING";
+  ErrorSeverity2["ERROR"] = "ERROR";
+  ErrorSeverity2["CRITICAL"] = "CRITICAL";
+  return ErrorSeverity2;
+})(ErrorSeverity || {});
+var ErrorCategory = /* @__PURE__ */ ((ErrorCategory2) => {
+  ErrorCategory2["AUTHENTICATION"] = "auth";
+  ErrorCategory2["AUTHORIZATION"] = "authorization";
+  ErrorCategory2["VALIDATION"] = "validation";
+  ErrorCategory2["BUSINESS"] = "business";
+  ErrorCategory2["INFRASTRUCTURE"] = "infrastructure";
+  ErrorCategory2["EXTERNAL"] = "external";
+  ErrorCategory2["UNKNOWN"] = "unknown";
+  return ErrorCategory2;
+})(ErrorCategory || {});
+class ErrorFactory {
+  static createMetadata(metadata) {
+    return {
+      timestamp: Date.now(),
+      ...metadata
+    };
+  }
+  static create(options) {
+    return new SilgiError({
+      code: options.code ?? options.httpStatus ?? 500 /* INTERNAL_SERVER_ERROR */,
+      message: options.message,
+      category: options.category ?? "unknown" /* UNKNOWN */,
+      severity: options.severity ?? "ERROR" /* ERROR */,
+      httpStatus: options.httpStatus ?? 500 /* INTERNAL_SERVER_ERROR */,
+      metadata: this.createMetadata(options.metadata),
+      cause: options.cause,
+      context: options.context
+    });
+  }
+  // Predefined error creators
+  static authenticationError(message, context) {
+    return this.create({
+      message,
+      code: 401,
+      category: "auth" /* AUTHENTICATION */,
+      severity: "ERROR" /* ERROR */,
+      httpStatus: 401 /* UNAUTHORIZED */,
+      context
+    });
+  }
+  static authorizationError(message, context) {
+    return this.create({
+      message,
+      code: 403,
+      category: "authorization" /* AUTHORIZATION */,
+      severity: "ERROR" /* ERROR */,
+      httpStatus: 403 /* FORBIDDEN */,
+      context
+    });
+  }
+  static validationError(message, context) {
+    return this.create({
+      message,
+      code: 400,
+      category: "validation" /* VALIDATION */,
+      severity: "WARNING" /* WARNING */,
+      httpStatus: 400 /* BAD_REQUEST */,
+      context
+    });
+  }
+  static notFoundError(message, context) {
+    return this.create({
+      message,
+      code: 404,
+      category: "business" /* BUSINESS */,
+      severity: "WARNING" /* WARNING */,
+      httpStatus: 404 /* NOT_FOUND */,
+      context
+    });
+  }
+  static internalError(message, cause) {
+    return this.create({
+      message,
+      code: 500,
+      category: "infrastructure" /* INFRASTRUCTURE */,
+      severity: "CRITICAL" /* CRITICAL */,
+      httpStatus: 500 /* INTERNAL_SERVER_ERROR */,
+      cause
+    });
+  }
+}
+class SilgiError extends Error {
+  code;
+  category;
+  severity;
+  httpStatus;
+  metadata;
+  context;
+  cause;
+  constructor(error) {
+    super(error.message);
+    this.name = "SilgiError";
+    this.code = error.code;
+    this.category = error.category;
+    this.severity = error.severity;
+    this.httpStatus = error.httpStatus;
+    this.metadata = error.metadata ?? { timestamp: Date.now() };
+    this.context = error.context;
+    this.cause = error.cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  toString() {
+    let str = `${this.name} [${this.code}] ${this.severity}: ${this.message}`;
+    str += `
+Category: ${this.category}`;
+    str += `
+HTTP Status: ${this.httpStatus}`;
+    if (this.context) {
+      str += `
+Context: ${JSON.stringify(this.context, null, 2)}`;
+    }
+    if (this.metadata) {
+      str += `
+Metadata: ${JSON.stringify(this.metadata, null, 2)}`;
+    }
+    if (this.stack) {
+      str += `
+${this.stack}`;
+    }
+    return str;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      category: this.category,
+      severity: this.severity,
+      httpStatus: this.httpStatus,
+      metadata: this.metadata,
+      context: this.context,
+      stack: this.stack
+    };
+  }
+  static isError(error) {
+    return error instanceof SilgiError || typeof error === "object" && error !== null && "name" in error && error.name === "SilgiError";
+  }
+  static from(error) {
+    if (error instanceof SilgiError) {
+      return error;
+    }
+    return ErrorFactory.internalError(
+      error instanceof Error ? error.message : String(error),
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function isBaseError(error) {
+  return typeof error === "object" && error !== null && "code" in error && "message" in error && "category" in error && "severity" in error && "httpStatus" in error;
+}
+
+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
+  };
+}
+
+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);
+  }
+}
+
+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;
+}
+
+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");
+}
+
+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();
+  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.options.putStorage ?? void 0,
+    options: config.options ?? {},
+    hooks,
+    callHook: hooks.callHook,
+    addHooks: hooks.addHooks,
+    hook: hooks.hook,
+    ready: () => {
+      return hooks.callHook("ready", silgi);
+    },
+    envOptions: config.envOptions ?? {},
+    close: () => hooks.callHook("close", silgi),
+    logger: createConsola(defu(config.options?.consolaOptions ?? {}, {
+      tag: "silgi"
+    })).withTag("silgi"),
+    captureError: config.captureError ?? (() => {
+    }),
+    routeRules: void 0
+  };
+  const routeRules = createRouteRules();
+  routeRules.importRules(config.options.routeRules ?? {});
+  silgi.routeRules = routeRules;
+  silgi.hooks.addHooks(silgi.options.hooks);
+  await runSilgiPlugins(silgi);
+  await scanAction(silgi);
+  if (!silgi.storage) {
+    silgi.storage = await createStorage(silgi);
+  }
+  silgi.shared.storage = (...data) => {
+    return useSilgiStorage(...data);
+  };
+  silgi.shared.runtimeConfig = silgi.options.runtimeConfig;
+  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;
+}
+
+function silgi(event) {
+  return {
+    execute: (uriString, input, source, queryParams) => {
+      return execute(uriString, input, event, source, queryParams);
+    }
+  };
+}
+async function execute(uriString, input, event, source, queryParams) {
+  const silgiCtx = useSilgi();
+  const config = {
+    returnNull: false
+  };
+  try {
+    const operation = parseURI(uriString, silgiCtx.uris);
+    if (!operation) {
+      throw ErrorFactory.create({ message: "Invalid URI", httpStatus: HttpStatus.BAD_REQUEST });
+    }
+    let success = false;
+    let cached = false;
+    let result;
+    const handler = silgiCtx.scannedHandlers.get(operation.uri);
+    if (!handler) {
+      throw ErrorFactory.create({
+        message: "execute not found",
+        httpStatus: HttpStatus.NOT_FOUND,
+        context: {
+          uri: uriString
+        }
+      });
+    }
+    await silgiCtx.callHook("execute:before", {
+      operation,
+      input,
+      event,
+      modules: handler.modules,
+      source,
+      config
+    });
+    if (config.returnNull) {
+      return result;
+    }
+    const cacheData = await cacheExecute(input, operation, handler, event);
+    if (cacheData?.success) {
+      result = cacheData.data;
+      success = cacheData.success;
+      cached = cacheData.cached;
+    } else {
+      let parameters = defu$1(operation.routerParams, operation.query) || {};
+      if (queryParams) {
+        parameters = defu$1(queryParams, parameters);
+      }
+      silgiCtx.shared.silgi = silgi(event);
+      result = await handler?.handler(
+        defu$1(input, { parameters }),
+        silgiCtx.shared,
+        event,
+        source
+      );
+      success = true;
+    }
+    await silgiCtx.callHook("execute:after", {
+      operation,
+      input,
+      event,
+      result,
+      success,
+      source,
+      modules: handler.modules,
+      config
+    });
+    if (!cached) {
+      if (success && cacheData?.cachedKey && handler.storage) {
+        await useSilgiStorage(handler.storage.base).setItem(cacheData.cachedKey, result, handler.storage.options);
+      }
+    }
+    return result;
+  } catch (err) {
+    await silgiCtx.callHook("execute:error", {
+      input,
+      event,
+      source,
+      error: err instanceof Error ? err : new Error(String(err)),
+      timestamp: Date.now(),
+      config
+    });
+    silgiCtx.captureError(SilgiError.from(err), {
+      event,
+      tags: ["execute"]
+    });
+    throw err;
+  }
+}
+async function cacheExecute(input, operation, handler, event) {
+  if (!handler.storage)
+    return;
+  const cacheKey = handler.storage ? await generateStorageKey({
+    operation,
+    input,
+    keyGenerator: handler.storage.key,
+    storageOptions: handler.storage,
+    requestId: event?.requestId
+  }) : null;
+  if (cacheKey) {
+    const cachedResult = await useSilgiStorage(handler.storage.base).getItem(cacheKey);
+    if (cachedResult !== null) {
+      return {
+        success: true,
+        data: normalizeResult(cachedResult),
+        cached: true,
+        cachedKey: cacheKey
+      };
+    }
+  }
+  return {
+    success: false,
+    data: null,
+    cached: false,
+    cachedKey: cacheKey
+  };
+}
+
+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);
+}
+
+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;
+}
+
+function createSchema(silgiType) {
+  return silgiType;
+}
+
+function createService(variables) {
+  return variables;
+}
+
+function createShared(shared) {
+  return shared;
+}
+
+function storageMount(silgi) {
+  const _silgi = silgi || useSilgi();
+  return (base, driver) => {
+    const existingStorage = _silgi.storage.getMount(base);
+    if (existingStorage) {
+      return existingStorage.driver;
+    }
+    const storage = _silgi.storage.mount(base, driver);
+    return storage;
+  };
+}
+
+const autoImportTypes = [
+  "ExtractInputFromURI",
+  "ExtractOutputFromURI",
+  "ExtractPathParamsFromURI",
+  "ExtractQueryParamsFromURI"
+];
+
+export { ErrorCategory, ErrorFactory, ErrorSeverity, HttpStatus, SilgiError, autoImportTypes, createSchema, createService, createShared, createSilgi, createStorage, getEvent, getEventContext, isBaseError, mergeSchemas, mergeServices, mergeShared, parseURI, replaceRuntimeValues, silgi, silgiCtx, storageMount, tryUseSilgi, useSilgi, useSilgiStorage };