silgi 0.0.14 → 0.1.2

package/dist/index.mjs

@@ -1,7 +1,465 @@
-export { c as createSilgi, d as defineService, a as defineSilgiPlugin, s as silgiCtx, e as useHook, u as useShared, b as useSilgi } from './shared/silgi.BMCYk2cR.mjs';
-import 'consola';
-import 'hookable';
-import 'node:buffer';
-import 'node:fs';
-import 'node:path';
+import { createConsola } from 'consola';
+import defu, { defu as defu$1 } from 'defu';
+import { createHooks } from 'hookable';
+import { applyDefaults } from 'untyped';
+import { u as useSilgi, n as normalizeResult, S as SilgiConfigSchema, s as silgiCtx, t as tryUseSilgi } from './shared/silgi.wK7ZsagJ.mjs';
+export { r as relativeWithDot, a as useHook, b as useShared } from './shared/silgi.wK7ZsagJ.mjs';
+import satisfies from 'semver/functions/satisfies.js';
+import { l as loadSilgiModuleInstance, p as parseURI, S as SilgiError, u as useStorage, a as SilgiErrorCode, g as generateStorageKey, s as scanHandler, c as createStorage } from './shared/silgi.CbXGs1ur.mjs';
+export { b as createResolver, d as generateURI } from './shared/silgi.CbXGs1ur.mjs';
+import { defineEventHandler, getQuery, readBody } from 'h3';
 import 'unctx';
+import 'pathe';
+import 'std-env';
+import 'node:fs';
+import 'node:buffer';
+import 'klona';
+import 'unstorage';
+import 'unstorage/drivers/memory';
+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);
+  } 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.raw);
+    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 {
+      silgiCtx.shared.silgi = (_event) => silgi(_event || event);
+      result = await handler?.handler(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
+          });
+          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 = {
+    types: config.types,
+    _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 scanHandler(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 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 mergeSilgiTypes(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 createType(silgiType) {
+  return silgiType;
+}
+
+export { SilgiError, SilgiHelper, createService, createShared, createSilgi, createType, defineSilgiModule, mergeServices, mergeShared, mergeSilgiTypes, normalizeResult, parseURI, silgi, silgiCtx, tryUseSilgi, useSilgi };