silgi 0.3.13 → 0.4.1

package/dist/index.mjs

@@ -1,503 +0,0 @@
-import { createConsola } from 'consola';
-import defu, { defu as defu$1 } from 'defu';
-import { createHooks } from 'hookable';
-import { applyDefaults } from 'untyped';
-import { u as useSilgi, a as loadSilgiModuleInstance, p as parseURI, S as SilgiError, b as useStorage, n as normalizeResult, c as SilgiErrorCode, g as generateStorageKey, d as SilgiConfigSchema, s as scanAction, e as createStorage, f as silgiCtx, t as tryUseSilgi } from './shared/silgi.D2yb1XAa.mjs';
-export { h as createResolver, l as loadSilgiConfig, r as relativeWithDot, i as useHook, j as useShared } from './shared/silgi.D2yb1XAa.mjs';
-import satisfies from 'semver/functions/satisfies.js';
-import { defineEventHandler, getQuery, readBody } from 'h3';
-import 'node:fs';
-import 'pathe';
-import 'node:buffer';
-import 'klona';
-import 'unstorage';
-import 'unstorage/drivers/memory';
-import 'unctx';
-import 'c12';
-import 'std-env';
-import 'node:url';
-import 'mlly';
-import 'pathe/utils';
-
-const SEMANTIC_VERSION_RE = /-\d+\.[0-9a-f]+/;
-function normalizeSemanticVersion(version) {
-  return version.replace(SEMANTIC_VERSION_RE, "");
-}
-const SILGI_VERSION_RE = /^v/g;
-function getSilgiVersion(silgi = useSilgi()) {
-  const rawVersion = silgi?._version || silgi?.version || silgi?.constructor?.version;
-  if (typeof rawVersion !== "string") {
-    throw new TypeError("Cannot determine silgi version! Is current instance passed?");
-  }
-  return rawVersion.replace(SILGI_VERSION_RE, "");
-}
-async function checkSilgiCompatibility(constraints, silgi = useSilgi()) {
-  const issues = [];
-  if (constraints.silgi) {
-    const silgiVersion = getSilgiVersion(silgi);
-    if (!satisfies(normalizeSemanticVersion(silgiVersion), constraints.silgi, { includePrerelease: true })) {
-      issues.push({
-        name: "silgi",
-        message: `Silgi version \`${constraints.silgi}\` is required but currently using \`${silgiVersion}\``
-      });
-    }
-  }
-  await silgi.callHook("kit:compatibility", constraints, issues);
-  issues.toString = () => issues.map((issue) => ` - [${issue.name}] ${issue.message}`).join("\n");
-  return issues;
-}
-function hasInstalledModule(moduleKey, silgi = useSilgi()) {
-  const find = silgi.options._installedModules.find(({ meta }) => meta.configKey === moduleKey);
-  return find?.active ?? false;
-}
-
-async function installModules(silgi) {
-  for (const module of Object.keys(silgi._initializedModules)) {
-    if (hasInstalledModule(module)) {
-      silgi.logger.info(`Module ${module} installeddddd`);
-    }
-    try {
-      const silgiModule = silgi._initializedModules[module];
-      await installModule(silgiModule, silgi);
-    } catch (err) {
-      silgi.logger.error(err);
-    }
-  }
-}
-async function installModule(moduleToInstall, silgi = useSilgi(), inlineOptions) {
-  const { silgiModule } = await loadSilgiModuleInstance(moduleToInstall);
-  const res = await silgiModule({}, silgi, false) ?? {};
-  if (res === false) {
-    return false;
-  }
-  const metaData = await silgiModule.getMeta?.();
-  const installedModule = silgi.options._installedModules.find((m) => m.meta.configKey === metaData?.configKey);
-  if (installedModule) {
-    installedModule.active = true;
-  } else {
-    throw new Error(`Module ${metaData?.name} not found`);
-  }
-}
-function getModule(configKey, silgi = useSilgi()) {
-  if (silgi._initializedModules[configKey]) {
-    return true;
-  }
-  return false;
-}
-
-function silgi(event) {
-  return {
-    execute: (uriString, input) => {
-      return execute(uriString, input, event);
-    }
-  };
-}
-async function execute(uriString, input, event) {
-  const silgiCtx = useSilgi();
-  if (event) {
-    silgiCtx.callHook("event:before", event);
-  }
-  let success = false;
-  let cached = false;
-  let error;
-  let result;
-  let operation;
-  try {
-    operation = parseURI(uriString, silgiCtx.uris);
-  } catch {
-    throw new SilgiError({
-      code: "INVALID_URI",
-      message: `Invalid URI: ${uriString}`
-    });
-  }
-  if (!operation) {
-    throw new SilgiError({
-      code: "INVALID_URI",
-      message: `Invalid URI: ${uriString}`
-    });
-  }
-  const hookContext = {
-    operation,
-    input,
-    event
-  };
-  try {
-    await silgiCtx.callHook("method:before", {
-      operation,
-      input,
-      event
-    });
-    const handler = silgiCtx.scannedHandlers.get(operation.uri);
-    if (!handler) {
-      return {
-        success: false,
-        error: {
-          code: "METHOD_NOT_FOUND",
-          message: `Method ${String(operation.methodName)} not found`
-        }
-      };
-    }
-    if (event)
-      await silgiCtx.callHook("event:before", event);
-    const cacheData = await cacheExecute(operation.raw, input, operation, handler, event);
-    await callModules(operation, handler, input, result, 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("method:after", {
-      operation,
-      input,
-      event,
-      result,
-      success
-    });
-    if (!cached) {
-      if (success && cacheData?.cachedKey && handler.storage) {
-        await useStorage(handler.storage.base).setItem(cacheData.cachedKey, result, handler.storage.options);
-      }
-    }
-    return { success: true, data: normalizeResult(result), cached };
-  } catch (err) {
-    error = err instanceof Error ? err : new Error("Unknown error");
-    if (error instanceof SilgiError) {
-      return {
-        success: false,
-        error: {
-          code: error.code,
-          message: error.message,
-          details: error.details
-        }
-      };
-    }
-    await silgiCtx.callHook("method:error", {
-      ...hookContext,
-      error,
-      timestamp: Date.now()
-    });
-    return {
-      success: false,
-      error: {
-        code: SilgiErrorCode.EXECUTION_ERROR,
-        message: error.message || String(error)
-      }
-    };
-  }
-}
-async function callModules(operation, handler, input, result, event) {
-  const silgi2 = useSilgi();
-  if (!handler.modules)
-    return;
-  for (const [moduleKey, config] of Object.entries(handler.modules)) {
-    const pluginConfig = config;
-    if (moduleKey) {
-      const module = getModule(moduleKey, silgi2);
-      if (module) {
-        await silgi2.callHook("module:before:excute", {
-          operation,
-          input,
-          event,
-          modules: handler.modules,
-          config: pluginConfig,
-          result
-        });
-      }
-    }
-  }
-}
-async function cacheExecute(uriString, 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 useStorage(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
-  };
-}
-
-class SilgiHelper {
-  setEvent(key, value) {
-    const silgi2 = useSilgi();
-    silgi2.options._eventContext ??= /* @__PURE__ */ new Map();
-    silgi2.options._eventContext.set(key, value);
-  }
-  getEvent(key) {
-    const silgi2 = useSilgi();
-    return silgi2.options._eventContext?.get(key);
-  }
-  async addH3App(router) {
-    const silgi2 = useSilgi();
-    silgi2.options.h3Router = router;
-    await silgi2.callHook("h3:app:setup", router);
-  }
-  async addNitroApp(nitro) {
-    const ctx = useSilgi();
-    ctx.options.nitro = nitro;
-    nitro.router.use("/srn/**", defineEventHandler({
-      handler: async (event) => {
-        const ctx2 = useSilgi();
-        if (ctx2.options.environment === "nitrojs" || ctx2.options.environment === "h3") {
-          const silgiConnect = silgi(event);
-          const query = getQuery(event);
-          const body = await readBody(event).catch(() => {
-          });
-          let newPath = event.path;
-          if (event.path.includes("?")) {
-            newPath = `${event.path}&method=${event.method}`;
-          } else {
-            newPath = `${event.path}?method=${event.method}`;
-          }
-          const data = await silgiConnect.execute(newPath, {
-            ...query,
-            ...body
-          });
-          if (data.success) {
-            return data.data;
-          }
-          return {
-            path: event.path,
-            method: event.method,
-            body,
-            query,
-            ...data
-          };
-        }
-      }
-    }));
-    await ctx.callHook("h3:app:setup", nitro.router);
-  }
-  /**
-   * [...router.ts] tum router tarayan ve ona gore isteklere yonlendiren alan.
-   */
-  // methods: ["delete", "get", "head", "options", "patch", "post", "put"]
-  async handler(_request) {
-  }
-}
-
-const silgiHooks = [
-  "close",
-  "ready",
-  "event:before",
-  "app:setup:start",
-  /* plugin hooks */
-  "module:register:after",
-  "module:register:before",
-  "module:setup:finish",
-  "module:error",
-  "module:before:excute",
-  "module:after:excute",
-  /* method hooks */
-  "method:after",
-  "method:before",
-  "method:error",
-  "method:finally",
-  "h3:app:setup",
-  // Kit
-  "kit:compatibility"
-];
-
-const version = "0.0.1";
-async function createSilgi(config) {
-  const hooks = createHooks();
-  await applyDefaults(SilgiConfigSchema, config.options);
-  const silgi = {
-    schemas: config.schemas,
-    _version: version,
-    services: config.services,
-    shared: config.shared,
-    uris: config.uris,
-    scannedHandlers: /* @__PURE__ */ new Map(),
-    storage: undefined,
-    _initializedModules: config._initializedModules,
-    options: config.options,
-    hooks,
-    hooksNames: silgiHooks,
-    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")
-    // TODO: shared, uris, services burada olacak
-  };
-  await scanAction(silgi);
-  silgi.storage = await createStorage(silgi);
-  silgi.shared.storage = (...data) => {
-    return useStorage(...data);
-  };
-  if (silgiCtx.tryUse()) {
-    silgiCtx.unset();
-    silgiCtx.set(silgi);
-  } else {
-    silgiCtx.set(silgi);
-    silgi.hook("close", () => silgiCtx.unset());
-  }
-  silgi.options.helper = new SilgiHelper();
-  await installModules(silgi);
-  silgi.logger.info("Silgi installed");
-  hooks.hookOnce("close", async () => {
-    hooks.removeAllHooks();
-    await silgi.storage.dispose();
-  });
-  return silgi.options.helper;
-}
-
-function silgiFetchRequestInterceptor(ctx) {
-  ctx.request = fillPath(ctx.request, ctx.options.path);
-}
-function createSilgiFetch(options, localFetch) {
-  return (url, opts = {}) => {
-    opts = typeof options === "function" ? options(opts) : { ...options, ...opts };
-    if (!opts.method)
-      opts.method = "get";
-    const $fetch = getFetch(url, opts, localFetch);
-    return $fetch(fillPath(url, opts?.path), opts);
-  };
-}
-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 = {}) {
-  for (const [k, v] of Object.entries(params))
-    path = path.replace(`{${k}}`, encodeURIComponent(String(v)));
-  return path;
-}
-
-function defineSilgiModule(definition) {
-  if (definition) {
-    return _defineSilgiModule(definition);
-  }
-  return {
-    with: (definition2) => _defineSilgiModule(definition2)
-  };
-}
-function _defineSilgiModule(definition) {
-  if (typeof definition === "function") {
-    return _defineSilgiModule({ setup: definition });
-  }
-  const module = defu$1(definition, { meta: {} });
-  module.meta.configKey ||= module.meta.name;
-  async function getOptions(inlineOptions, silgi = useSilgi()) {
-    const nuxtConfigOptionsKey = module.meta.configKey || module.meta.name;
-    const nuxtConfigOptions = nuxtConfigOptionsKey && nuxtConfigOptionsKey in silgi.options ? silgi.options[nuxtConfigOptionsKey] : {};
-    const optionsDefaults = module.defaults instanceof Function ? await module.defaults(silgi) : module.defaults ?? {};
-    const options = defu$1(inlineOptions, nuxtConfigOptions, optionsDefaults);
-    return Promise.resolve(options);
-  }
-  async function normalizedModule(inlineOptions, silgi = tryUseSilgi(), cli = false) {
-    if (!silgi) {
-      throw new TypeError("Cannot use module outside of Silgi context");
-    }
-    const uniqueKey = module.meta.configKey || module.meta.name;
-    if (uniqueKey) {
-      silgi.options._requiredModules ||= {};
-      if (silgi.options._requiredModules[uniqueKey]) {
-        return false;
-      }
-      silgi.options._requiredModules[uniqueKey] = true;
-    }
-    if (module.meta.compatibility) {
-      const issues = await checkSilgiCompatibility(module.meta.compatibility, silgi);
-      if (issues.length) {
-        silgi.logger.warn(`Module \`${module.meta.name}\` is disabled due to incompatibility issues:
-${issues.toString()}`);
-        return;
-      }
-    }
-    const _options = await getOptions(inlineOptions, silgi);
-    if (module.hooks) {
-      silgi.hooks.addHooks(module.hooks);
-    }
-    const start = performance.now();
-    const res = cli ? await module.cli?.call(null, _options, silgi) ?? {} : await module.setup?.call(null, _options, silgi) ?? {};
-    const perf = performance.now() - start;
-    const setupTime = Math.round(perf * 100) / 100;
-    if (setupTime > 5e3 && uniqueKey !== "@silgi/telemetry") {
-      silgi.logger.warn(`Slow module \`${uniqueKey || "<no name>"}\` took \`${setupTime}ms\` to setup.`);
-    } else if (silgi.options.debug) {
-      silgi.logger.info(`Module \`${uniqueKey || "<no name>"}\` took \`${setupTime}ms\` to setup.`);
-    }
-    if (res === false) {
-      return false;
-    }
-    return defu$1(res, {
-      timings: {
-        setup: setupTime
-      }
-    });
-  }
-  normalizedModule.getMeta = () => Promise.resolve(module.meta);
-  normalizedModule.getOptions = getOptions;
-  normalizedModule.cli = normalizedModule;
-  return normalizedModule;
-}
-
-function merge(items) {
-  return Object.assign({}, ...Array.isArray(items) ? items : [items]);
-}
-function mergeSchemas(typesOrArray) {
-  return merge(typesOrArray);
-}
-function mergeServices(servicesOrArray) {
-  return merge(servicesOrArray);
-}
-function mergeShared(sharedOrArray) {
-  return merge(sharedOrArray);
-}
-
-function createService(variables) {
-  return variables;
-}
-
-function createShared(shared) {
-  return shared;
-}
-
-function createSchema(silgiType) {
-  return silgiType;
-}
-
-const types = [
-  "ExtractInputFromURI",
-  "ExtractOutputFromURI",
-  "ExtractRouterParamsFromURI"
-];
-
-export { SilgiError, SilgiHelper, createSchema, createService, createShared, createSilgi, createSilgiFetch, defineSilgiModule, mergeSchemas, mergeServices, mergeShared, normalizeResult, parseURI, silgi, silgiCtx, silgiFetchRequestInterceptor, tryUseSilgi, types, useSilgi };