silgi 0.7.1 → 0.7.3

package/dist/core/createSilgi.mjs

@@ -1,84 +0,0 @@
-import { createConsola } from 'consola';
-import defu from 'defu';
-import { isEvent } from 'h3';
-import { createHooks } from 'hookable';
-import { applyDefaults } from 'untyped';
-import { SilgiConfigSchema } from '../schema/index.mjs';
-import { silgiCtx } from './unctx.mjs';
-import { scanAction } from './uris/uri.mjs';
-import { createStorage, useSilgiStorage } from './utils/storage.mjs';
-
-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;
-}
-
-export { createSilgi };

package/dist/core/error.mjs

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

package/dist/core/fetch/ofetch.mjs

@@ -1,35 +0,0 @@
-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;
-}
-
-export { createSilgiFetch };

package/dist/core/parser.mjs

@@ -1,136 +0,0 @@
-import { writeFileSync } from 'node:fs';
-import { parseSync } from '@oxc-parser/wasm';
-
-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
-  // }
-}
-
-export { SchemaParser };

package/dist/core/silgi.mjs

@@ -1,114 +0,0 @@
-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) => {
-      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
-  };
-}
-
-export { execute, silgi };

package/dist/core/silgiApp.mjs

@@ -1,15 +0,0 @@
-import { getContext } from 'unctx';
-
-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 { silgiCLICtx, tryUseSilgiCLI, useSilgiCLI };

package/dist/core/unctx.mjs

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

@@ -1,33 +0,0 @@
-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 {
-      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);
-  }
-}
-
-export { findAction, scanAction };