silgi 0.24.15 → 0.24.17

package/dist/core/error.mjs

@@ -0,0 +1,227 @@
+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;
+}
+
+export { ErrorCategory, ErrorFactory, ErrorSeverity, HttpStatus, SilgiError, isBaseError };

package/dist/core/index.mjs

@@ -0,0 +1,8 @@
+const autoImportTypes = [
+  "ExtractInputFromURI",
+  "ExtractOutputFromURI",
+  "ExtractPathParamsFromURI",
+  "ExtractQueryParamsFromURI"
+];
+
+export { autoImportTypes };

package/dist/core/routeRules.mjs

@@ -0,0 +1,288 @@
+import { withoutTrailingSlash, withLeadingSlash } from 'ufo';
+
+function patternToRegex(pattern) {
+  let regexStr = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  regexStr = regexStr.replace(/\*\*/g, ".+");
+  regexStr = regexStr.replace(/\*/g, "[^/]+");
+  regexStr = regexStr.replace(/:([^/]+)/g, "([^/]+)");
+  return new RegExp(`^${regexStr}$`);
+}
+function extractParams(url, pattern) {
+  url = withoutTrailingSlash(withLeadingSlash(url));
+  pattern = withoutTrailingSlash(withLeadingSlash(pattern));
+  if (!pattern.includes(":"))
+    return null;
+  const paramNames = [];
+  const patternRegex = pattern.replace(/:([^/]+)/g, (_, name) => {
+    paramNames.push(name);
+    return "([^/]+)";
+  });
+  const regex = new RegExp(`^${patternRegex}$`);
+  const matches = url.match(regex);
+  if (!matches)
+    return null;
+  const params = {};
+  paramNames.forEach((name, i) => {
+    params[name] = matches[i + 1];
+  });
+  return Object.keys(params).length > 0 ? params : null;
+}
+function matchesPattern(url, pattern) {
+  url = withoutTrailingSlash(withLeadingSlash(url));
+  pattern = withoutTrailingSlash(withLeadingSlash(pattern));
+  if (url === pattern)
+    return true;
+  if (pattern.endsWith("/**")) {
+    const basePath = pattern.slice(0, -3);
+    return url === basePath || url.startsWith(`${basePath}/`);
+  }
+  const urlParts = url.split("/");
+  const patternParts = pattern.split("/");
+  if (!pattern.includes("**") && urlParts.length !== patternParts.length) {
+    return false;
+  }
+  if (pattern.includes("/**/")) {
+    const [prefix, ...suffixParts] = pattern.split("/**/");
+    const suffix = suffixParts.join("/");
+    return url.startsWith(prefix) && (!suffix || url.endsWith(`/${suffix}`));
+  }
+  return patternToRegex(pattern).test(url);
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object")
+    return obj;
+  if (typeof obj === "function")
+    return obj;
+  if (Array.isArray(obj))
+    return obj.map(deepClone);
+  const cloned = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      cloned[key] = deepClone(obj[key]);
+    }
+  }
+  return cloned;
+}
+function mergeConfigs(...configs) {
+  const result = {};
+  for (const config of configs) {
+    if (!config)
+      continue;
+    for (const key in config) {
+      const value = config[key];
+      if (value && typeof value === "object" && !Array.isArray(value) && result[key] && typeof result[key] === "object" && typeof result[key] !== "function") {
+        const resultValue = result[key];
+        const valueToMerge = value;
+        result[key] = mergeConfigs(resultValue, valueToMerge);
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function createRouteRules() {
+  let _rules = {};
+  let _mergedRules = {};
+  let _rulesModified = false;
+  function getRules() {
+    return deepClone(_rules);
+  }
+  function importRules(config) {
+    const normalizedConfig = {};
+    for (const pattern in config) {
+      normalizedConfig[withoutTrailingSlash(withLeadingSlash(pattern))] = deepClone(config[pattern]);
+    }
+    _rules = normalizedConfig;
+    _rulesModified = true;
+    updateMergeRules();
+  }
+  function exportRules() {
+    return deepClone(_rules);
+  }
+  function addRule(pattern, config) {
+    _rules[withoutTrailingSlash(withLeadingSlash(pattern))] = deepClone(config);
+    _rulesModified = true;
+    updateMergeRules();
+  }
+  function updateRule(pattern, config) {
+    const normalizedPattern = withoutTrailingSlash(withLeadingSlash(pattern));
+    if (_rules[normalizedPattern]) {
+      _rules[normalizedPattern] = { ..._rules[normalizedPattern], ...deepClone(config) };
+    } else {
+      _rules[normalizedPattern] = deepClone(config);
+    }
+    _rulesModified = true;
+    updateMergeRules();
+  }
+  function removeRule(pattern) {
+    delete _rules[withoutTrailingSlash(withLeadingSlash(pattern))];
+    _rulesModified = true;
+    updateMergeRules();
+  }
+  function matchesRule(url, pattern) {
+    return matchesPattern(withoutTrailingSlash(withLeadingSlash(url)), withoutTrailingSlash(withLeadingSlash(pattern)));
+  }
+  function getMatchingPatterns(url) {
+    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
+    return Object.keys(_rules).filter((pattern) => matchesPattern(normalizedUrl, pattern)).sort((a, b) => {
+      if (a === url)
+        return -1;
+      if (b === url)
+        return 1;
+      const aSegments = a.split("/").filter(Boolean).length;
+      const bSegments = b.split("/").filter(Boolean).length;
+      if (aSegments !== bSegments)
+        return bSegments - aSegments;
+      const aWildcards = (a.match(/\*/g) || []).length;
+      const bWildcards = (b.match(/\*/g) || []).length;
+      if (aWildcards !== bWildcards)
+        return aWildcards - bWildcards;
+      const aDoubleWildcards = (a.match(/\*\*/g) || []).length;
+      const bDoubleWildcards = (b.match(/\*\*/g) || []).length;
+      if (aDoubleWildcards !== bDoubleWildcards)
+        return aDoubleWildcards - bDoubleWildcards;
+      return b.length - a.length;
+    });
+  }
+  function getConfig(url) {
+    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
+    if (_rulesModified) {
+      updateMergeRules();
+    }
+    if (_mergedRules[normalizedUrl]) {
+      return deepClone(_mergedRules[normalizedUrl]);
+    }
+    const patterns = getMatchingPatterns(normalizedUrl);
+    if (!patterns.length)
+      return null;
+    const mergedConfig = {};
+    for (let i = patterns.length - 1; i >= 0; i--) {
+      const pattern = patterns[i];
+      const patternConfig = _mergedRules[pattern] || _rules[pattern];
+      Object.assign(mergedConfig, deepClone(patternConfig));
+    }
+    _mergedRules[normalizedUrl] = deepClone(mergedConfig);
+    return mergedConfig;
+  }
+  function computeMergedConfig(url, patterns) {
+    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
+    const matchingPatterns = patterns || getMatchingPatterns(normalizedUrl);
+    if (!matchingPatterns.length)
+      return {};
+    const allPatternsHaveCache = matchingPatterns.every((pattern) => !!_mergedRules[pattern]);
+    if (allPatternsHaveCache) {
+      return matchingPatterns.reduceRight((result, pattern) => mergeConfigs(result, deepClone(_mergedRules[pattern])), {});
+    }
+    return matchingPatterns.reduceRight((result, pattern) => mergeConfigs(result, deepClone(_rules[pattern])), {});
+  }
+  function getParams(url, pattern) {
+    return extractParams(withoutTrailingSlash(withLeadingSlash(url)), withoutTrailingSlash(withLeadingSlash(pattern)));
+  }
+  function match(url) {
+    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
+    const patterns = getMatchingPatterns(normalizedUrl);
+    if (!patterns.length)
+      return null;
+    const bestPattern = patterns[0];
+    return {
+      pattern: bestPattern,
+      config: deepClone(_rules[bestPattern]),
+      params: getParams(normalizedUrl, bestPattern)
+    };
+  }
+  function clear() {
+    _rules = {};
+    clearMergedRules();
+    _rulesModified = false;
+  }
+  function clearMergedRules() {
+    _mergedRules = {};
+    _rulesModified = true;
+  }
+  function precomputeMergedRules(urls) {
+    if (_rulesModified) {
+      updateMergeRules();
+    }
+    for (const url of urls) {
+      const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
+      if (!_mergedRules[normalizedUrl]) {
+        const patterns = getMatchingPatterns(normalizedUrl);
+        if (patterns.length) {
+          _mergedRules[normalizedUrl] = computeMergedConfig(normalizedUrl, patterns);
+        }
+      }
+    }
+  }
+  function setMergedRule(url, config) {
+    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
+    _mergedRules[normalizedUrl] = deepClone(config);
+    if (url.includes("*") || url.includes(":")) {
+      _rulesModified = false;
+    }
+  }
+  function getMergedRules() {
+    return deepClone(_mergedRules);
+  }
+  function configure(config) {
+    importRules(config);
+  }
+  function updateMergeRules() {
+    if (!_rulesModified) {
+      return _mergedRules;
+    }
+    _mergedRules = {};
+    const rulePatterns = Object.keys(_rules);
+    for (const pattern of rulePatterns) {
+      const patterns = getMatchingPatterns(pattern);
+      _mergedRules[pattern] = computeMergedConfig(pattern, patterns);
+    }
+    for (const pattern of rulePatterns) {
+      if (pattern.includes("/:")) {
+        const segments = pattern.split("/");
+        let partialPath = "";
+        for (const segment of segments) {
+          if (segment) {
+            partialPath += `/${segment}`;
+            if (segment.startsWith(":") && partialPath !== pattern) {
+              const samplePath = partialPath.replace(/:\w+/g, "sample");
+              const patterns = getMatchingPatterns(samplePath);
+              _mergedRules[samplePath] = computeMergedConfig(samplePath, patterns);
+            }
+          }
+        }
+      }
+    }
+    _rulesModified = false;
+    return _mergedRules;
+  }
+  return {
+    // Public getters that return a cloned version to prevent direct modification
+    get rules() {
+      return getRules();
+    },
+    get mergedRules() {
+      return getMergedRules();
+    },
+    // API methods
+    importRules,
+    exportRules,
+    addRule,
+    updateRule,
+    removeRule,
+    matchesRule,
+    getMatchingPatterns,
+    getConfig,
+    getParams,
+    match,
+    clear,
+    clearMergedRules,
+    precomputeMergedRules,
+    setMergedRule,
+    getMergedRules,
+    configure,
+    updateMergeRules
+  };
+}
+
+export { createRouteRules };

package/dist/core/silgi.mjs

@@ -0,0 +1,128 @@
+import { defu } from 'defu';
+import { ErrorFactory, HttpStatus, SilgiError } from './error.mjs';
+import { useSilgi, normalizeResult } from './unctx.mjs';
+import { parseURI } from './uris/utils.mjs';
+import { useSilgiStorage, generateStorageKey } from './utils/storage.mjs';
+
+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(operation.routerParams, operation.query) || {};
+      if (queryParams) {
+        parameters = defu(queryParams, parameters);
+      }
+      silgiCtx.shared.silgi = silgi(event);
+      result = await handler?.handler(
+        defu(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
+  };
+}
+
+export { execute, silgi };

package/dist/core/silgiApp.mjs

@@ -0,0 +1,25 @@
+import consola from 'consola';
+import { createContext } from 'unctx';
+
+const silgiCLICtx = createContext();
+function useSilgiCLI() {
+  const instance = silgiCLICtx.tryUse();
+  if (!instance) {
+    throw new Error("Silgi instance is unavailable!");
+  }
+  return instance;
+}
+async function silgiCLIIClose() {
+  const silgi = silgiCLICtx.tryUse();
+  if (!silgi) {
+    return;
+  }
+  await silgi.close();
+  await silgi.callHook("close", silgi);
+  consola.withTag("silgi").success("Process terminated");
+}
+function tryUseSilgiCLI() {
+  return silgiCLICtx.tryUse();
+}
+
+export { silgiCLICtx, silgiCLIIClose, tryUseSilgiCLI, useSilgiCLI };

package/dist/core/storage.mjs

@@ -0,0 +1,15 @@
+import { useSilgi } from './unctx.mjs';
+
+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;
+  };
+}
+
+export { storageMount };