silgi 0.7.1 → 0.7.2

package/dist/core/index.mjs

@@ -1,16 +1,943 @@
-export { loadOptions } from './config/loader.mjs';
-export { silgiGenerateType } from './config/types.mjs';
-export { createSilgi } from './createSilgi.mjs';
-export { createSilgiFetch } from './fetch/ofetch.mjs';
-export { SchemaParser } from './parser.mjs';
-export { silgi } from './silgi.mjs';
-export { parseURI } from './uris/utils.mjs';
-export { mergeSchemas, mergeServices, mergeShared } from './utils/merge.mjs';
-export { getEvent } from './utils/event.mjs';
-export { createSchema } from './utils/schema.mjs';
-export { createService } from './utils/service.mjs';
-export { createShared } from './utils/shared.mjs';
-export { createStorage, useSilgiStorage } from './utils/storage.mjs';
-export { ErrorCategory, ErrorFactory, ErrorSeverity, HttpStatus, SilgiError, isBaseError } from './error.mjs';
-export { silgiCtx, tryUseSilgi, useSilgi } from './unctx.mjs';
-export { silgiCLICtx, tryUseSilgiCLI, useSilgiCLI } from './silgiApp.mjs';
+import { createConsola } from 'consola';
+import defu from 'defu';
+import { isEvent } from 'h3';
+import { createHooks } from 'hookable';
+import { defineUntypedSchema, applyDefaults } from 'untyped';
+import { isDebug, isTest, isDevelopment } from 'std-env';
+import { getContext } from 'unctx';
+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 { writeFileSync } from 'node:fs';
+import { parseSync } from '@oxc-parser/wasm';
+
+const common = defineUntypedSchema({
+  /**
+   * Environment to use.
+   *
+   * @default 'h3'
+   */
+  environment: {
+    $resolve: (val) => val ?? "h3"
+  },
+  /**
+   * Whether Nuxt is running in development mode.
+   *
+   * Normally, you should not need to set this.
+   */
+  dev: {
+    $resolve: (val) => val ?? Boolean(isDevelopment)
+  },
+  /**
+   * Whether your app is being unit tested.
+   */
+  test: {
+    $resolve: (val) => val ?? Boolean(isTest)
+  },
+  /**
+   * Set to `true` to enable debug mode.
+   *
+   * At the moment, it prints out hook names and timings on the server, and
+   * logs hook arguments as well in the browser.
+   *
+   */
+  debug: {
+    $resolve: (val) => val ?? isDebug
+  },
+  plugins: {
+    $resolve: (val) => (val || []).filter(Boolean)
+  },
+  $schema: {}
+});
+
+const internal = defineUntypedSchema({
+  /** @private */
+  _majorVersion: 4,
+  /** @private */
+  _generate: false,
+  /** @private */
+  _prepare: false,
+  /** @private */
+  _requiredPlugins: {},
+  /**
+   * @private
+   * @type {Array<{ meta: ModuleMeta; timings?: Record<string, number | undefined>; entryPath?: string }>}
+   */
+  _installedPlugins: [],
+  /** @private */
+  _plugins: [],
+  extensions: [".js", ".mjs", ".ts"]
+});
+
+const SilgiConfigSchema = {
+  ...common,
+  ...internal
+};
+
+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;
+  }
+  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
+        }
+      });
+    }
+    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
+  };
+}
+
+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 {
+      console.error("Property not found:", part);
+      break;
+    }
+  }
+  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);
+  }
+}
+
+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");
+}
+
+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();
+  await applyDefaults(SilgiConfigSchema, config.options);
+  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.storage ?? void 0,
+    options: config.options,
+    hooks,
+    callHook: hooks.callHook,
+    addHooks: hooks.addHooks,
+    hook: hooks.hook,
+    ready: () => {
+      return hooks.callHook("ready", silgi);
+    },
+    close: () => hooks.callHook("close", silgi),
+    logger: createConsola(defu(config.options.consolaOptions, {
+      tag: "silgi"
+    })).withTag("silgi"),
+    captureError: (error, context = {}) => {
+      const promise = hooks.callHookParallel("error", error, context).catch((error_) => {
+        console.error("Error while capturing another error", error_);
+      });
+      if (context.event && isEvent(context.event)) {
+        const errors = context.event.context.nitro?.errors;
+        if (errors) {
+          errors.push({ error, context });
+        }
+        if (context.event.waitUntil) {
+          context.event.waitUntil(promise);
+        }
+      }
+    }
+  };
+  await runSilgiPlugins(silgi);
+  await scanAction(silgi);
+  if (!silgi.storage) {
+    silgi.storage = await createStorage(silgi);
+  }
+  silgi.shared.storage = (...data) => {
+    return useSilgiStorage(...data);
+  };
+  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 createSilgiFetch(options, localFetch) {
+  return (url, opts) => {
+    const finalOpts = {
+      ...typeof options === "function" ? options(opts) : options,
+      ...opts,
+      method: opts.method || "get"
+    };
+    const $fetch = getFetch(url, finalOpts, localFetch);
+    return $fetch(fillPath(url, opts.params), finalOpts);
+  };
+}
+function getFetch(url, opts, localFetch) {
+  if (import.meta.server && localFetch) {
+    const isLocalFetch = url[0] === "/" && (!opts.baseURL || opts.baseURL[0] === "/");
+    if (isLocalFetch)
+      return localFetch;
+  }
+  return globalThis.$fetch;
+}
+function fillPath(path, params) {
+  if (!params) {
+    if (path.includes(":"))
+      throw new Error("Parametreler dogru kullanmal\u0131s\u0131n\u0131z");
+    return path;
+  }
+  if (!path.includes(":"))
+    throw new Error("Path parametler : ile belirtilmelidir");
+  let result = path;
+  for (const [key, value] of Object.entries(params)) {
+    result = result.replace(`:${key}`, value);
+  }
+  return result;
+}
+
+class SchemaParser {
+  options = {
+    debug: false
+  };
+  /**
+   *
+   */
+  constructor(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+  }
+  parseExports(content, filePath) {
+    const ast = parseSync(content, { sourceType: "module", sourceFilename: filePath });
+    if (this.options.debug)
+      writeFileSync(`${filePath}.ast.json`, JSON.stringify(ast.program, null, 2));
+    return {
+      exportVariables: (search, path) => this.parseTypeDeclarations(ast, search, path),
+      parseInterfaceDeclarations: (search, path) => this.parseInterfaceDeclarations(ast, search, path)
+      // parsePlugin: (path: string) => this.parsePlugin(ast, path),
+    };
+  }
+  parseVariableDeclaration(ast) {
+    return ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "VariableDeclaration");
+  }
+  parseTSInterfaceDeclaration(ast) {
+    return ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "TSInterfaceDeclaration");
+  }
+  parseTypeDeclarations(ast, find = "", path = "") {
+    const data = [];
+    for (const item of this.parseVariableDeclaration(ast)) {
+      for (const declaration of item.declaration.declarations) {
+        if (declaration.init?.callee?.name === find) {
+          const options = {};
+          if (declaration.init.arguments) {
+            for (const argument of declaration.init.arguments) {
+              for (const propertie of argument.properties) {
+                if (propertie.key.name === "name")
+                  options.pluginName = propertie.value.value;
+              }
+            }
+          }
+          for (const key in declaration.init.properties) {
+            const property = declaration.init.properties[key];
+            if (property.type === "ObjectProperty") {
+              if (property.key.name === "options") {
+                for (const key2 in property.value.properties) {
+                  const option = property.value.properties[key2];
+                  if (option.type === "ObjectProperty") {
+                    options[option.key.name] = option.value.value;
+                  }
+                }
+              }
+            }
+          }
+          options.type = false;
+          data.push({
+            exportName: declaration.id.name,
+            options,
+            // object: declaration.init,
+            path
+          });
+        }
+      }
+    }
+    return data;
+  }
+  parseInterfaceDeclarations(ast, find = "", path = "") {
+    const data = [];
+    for (const item of this.parseTSInterfaceDeclaration(ast)) {
+      if (!item?.declaration?.extends)
+        continue;
+      for (const declaration of item?.declaration?.extends) {
+        if (declaration.expression.name === find) {
+          const options = {};
+          options.type = true;
+          data.push({
+            exportName: item.declaration.id.name,
+            options,
+            // object: declaration.init,
+            path
+          });
+        }
+      }
+    }
+    return data;
+  }
+  // private parsePlugin(ast: any, path: string = '') {
+  //   const data = {
+  //     export: [],
+  //     name: '',
+  //     path: '',
+  //   } as DataTypePlugin
+  //   for (const item of this.parseVariableDeclaration(ast)) {
+  //     for (const declaration of item.declaration.declarations) {
+  //       if (declaration.init.callee?.name === 'defineSilgiModule') {
+  //         if (declaration.init.arguments) {
+  //           for (const argument of declaration.init.arguments) {
+  //             for (const propertie of argument.properties) {
+  //               if (propertie.key.name === 'name')
+  //                 data.name = propertie.value.value
+  //             }
+  //           }
+  //         }
+  //         data.export.push({
+  //           name: data.name,
+  //           as: camelCase(`${data.name}DefineSilgiModule`),
+  //           type: false,
+  //         })
+  //       }
+  //     }
+  //   }
+  //   for (const item of this.parseTSInterfaceDeclaration(ast)) {
+  //     if (!item?.declaration?.extends)
+  //       continue
+  //     for (const declaration of item?.declaration?.extends) {
+  //       if (declaration.expression.name === 'ModuleOptions') {
+  //         data.export.push({
+  //           name: item.declaration.id.name,
+  //           as: camelCase(`${data.name}ModuleOptions`),
+  //           type: true,
+  //         })
+  //       }
+  //       // TODO add other plugins
+  //     }
+  //   }
+  //   data.path = path
+  //   return data
+  // }
+}
+
+function silgi(event) {
+  return {
+    execute: (uriString, input) => {
+      return execute(uriString, input, event);
+    }
+  };
+}
+async function execute(uriString, input, event) {
+  const silgiCtx = useSilgi();
+  if (event) {
+    await silgiCtx.callHook("event:before", event);
+  }
+  let success = false;
+  let cached = false;
+  let result;
+  try {
+    const operation = parseURI(uriString, silgiCtx.uris);
+    if (!operation) {
+      throw ErrorFactory.create({ message: "Invalid URI", httpStatus: HttpStatus.BAD_REQUEST });
+    }
+    const handler = silgiCtx.scannedHandlers.get(operation.uri);
+    if (!handler) {
+      throw ErrorFactory.create({
+        message: "Action not found",
+        httpStatus: HttpStatus.NOT_FOUND,
+        context: {
+          uri: uriString
+        }
+      });
+    }
+    await silgiCtx.callHook("action:before", {
+      operation,
+      input,
+      event,
+      modules: handler.modules,
+      result
+    });
+    const cacheData = await cacheExecute(input, operation, handler, event);
+    if (cacheData?.success) {
+      result = cacheData.data;
+      success = cacheData.success;
+      cached = cacheData.cached;
+    } else {
+      const router = {
+        params: operation.routerParams,
+        query: operation.query
+      };
+      silgiCtx.shared.silgi = (_event) => silgi(_event || event);
+      result = await handler?.handler(router, input, silgiCtx.shared, event);
+      success = true;
+    }
+    await silgiCtx.callHook("action:after", {
+      operation,
+      input,
+      event,
+      result,
+      success,
+      modules: handler.modules
+    });
+    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("action:error", {
+      input,
+      event,
+      error: err instanceof Error ? err : new Error(String(err)),
+      timestamp: Date.now()
+    });
+    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 = 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);
+}
+
+function getEvent(event) {
+  return event.event || event || {};
+}
+
+function createSchema(silgiType) {
+  return silgiType;
+}
+
+function createService(variables) {
+  return variables;
+}
+
+function createShared(shared) {
+  return shared;
+}
+
+const silgiCLICtx = getContext("SilgiCLI");
+function useSilgiCLI() {
+  const instance = silgiCLICtx.tryUse();
+  if (!instance) {
+    throw new Error("Silgi instance is unavailable!");
+  }
+  return instance;
+}
+function tryUseSilgiCLI() {
+  return silgiCLICtx.tryUse();
+}
+
+export { ErrorCategory, ErrorFactory, ErrorSeverity, HttpStatus, SchemaParser, SilgiError, createSchema, createService, createShared, createSilgi, createSilgiFetch, createStorage, getEvent, isBaseError, mergeSchemas, mergeServices, mergeShared, parseURI, silgi, silgiCLICtx, silgiCtx, tryUseSilgi, tryUseSilgiCLI, useSilgi, useSilgiCLI, useSilgiStorage };