silgi 0.3.12 → 0.4.0

package/dist/shared/silgi.mBwNj1W0.mjs

@@ -1,386 +0,0 @@
-import { lstatSync, promises, existsSync } from 'node:fs';
-import { isAbsolute, dirname, resolve, normalize, join } from 'pathe';
-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 { getContext } from 'unctx';
-import { fileURLToPath } from 'node:url';
-import { resolvePath as resolvePath$1 } from 'mlly';
-import { resolveAlias as resolveAlias$1 } from 'pathe/utils';
-
-const silgiCtx = getContext("silgi");
-function useShared() {
-  const instance = silgiCtx.tryUse();
-  if (!instance) {
-    throw new Error("Silgi instance is unavailable!");
-  }
-  return instance.options.shared;
-}
-function useSilgi() {
-  const instance = silgiCtx.tryUse();
-  if (!instance) {
-    throw new Error("Silgi instance is unavailable!");
-  }
-  return instance;
-}
-function useHook() {
-  const instance = silgiCtx.tryUse();
-  if (!instance) {
-    throw new Error("Silgi instance is unavailable!");
-  }
-  return instance.hooks.hook;
-}
-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();
-}
-
-function getDirectory(p) {
-  try {
-    return isAbsolute(p) && lstatSync(p).isFile() ? dirname(p) : p;
-  } catch {
-  }
-  return p;
-}
-async function loadSilgiModuleInstance(silgiModule) {
-  if (typeof silgiModule === "string") {
-    throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
-  }
-  if (typeof silgiModule !== "function") {
-    throw new TypeError(`Nuxt module should be a function: ${silgiModule}`);
-  }
-  return { silgiModule };
-}
-
-var SilgiErrorCode = /* @__PURE__ */ ((SilgiErrorCode2) => {
-  SilgiErrorCode2["AUTH_UNAUTHORIZED"] = "AUTH_UNAUTHORIZED";
-  SilgiErrorCode2["AUTH_MISSING_CONTEXT"] = "AUTH_MISSING_CONTEXT";
-  SilgiErrorCode2["AUTH_INVALID_CONTEXT"] = "AUTH_INVALID_CONTEXT";
-  SilgiErrorCode2["AUTH_PERMISSION_DENIED"] = "AUTH_PERMISSION_DENIED";
-  SilgiErrorCode2["PLUGIN_ERROR"] = "PLUGIN_ERROR";
-  SilgiErrorCode2["METHOD_NOT_FOUND"] = "METHOD_NOT_FOUND";
-  SilgiErrorCode2["EXECUTION_ERROR"] = "EXECUTION_ERROR";
-  SilgiErrorCode2["CACHE_ERROR"] = "CACHE_ERROR";
-  SilgiErrorCode2["PLUGIN_ALREADY_EXISTS"] = "PLUGIN_ALREADY_EXISTS";
-  SilgiErrorCode2["PLUGIN_NOT_FOUND"] = "PLUGIN_NOT_FOUND";
-  SilgiErrorCode2["PLUGIN_INIT_ERROR"] = "PLUGIN_INIT_ERROR";
-  return SilgiErrorCode2;
-})(SilgiErrorCode || {});
-class SilgiError extends Error {
-  code;
-  details;
-  meta;
-  timestamp;
-  cause;
-  constructor(options) {
-    super(options.message);
-    this.name = "SilgiError";
-    this.code = options.code;
-    this.details = options.details;
-    this.meta = options.meta;
-    this.cause = options.cause;
-    this.timestamp = Date.now();
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-  // Improve error formatting
-  toString() {
-    let str = `${this.name} [${this.code}]: ${this.message}`;
-    if (this.details) {
-      str += `
-Details: ${JSON.stringify(this.details, null, 2)}`;
-    }
-    if (this.meta) {
-      str += `
-Meta: ${JSON.stringify(this.meta, null, 2)}`;
-    }
-    if (this.stack) {
-      str += `
-${this.stack}`;
-    }
-    return str;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      details: this.details,
-      meta: this.meta,
-      timestamp: this.timestamp,
-      stack: this.stack
-    };
-  }
-  static createFrom(error, code = "UNKNOWN_ERROR") {
-    if (error instanceof SilgiError) {
-      return error;
-    }
-    return new SilgiError({
-      code,
-      message: error instanceof Error ? error.message : String(error),
-      cause: error instanceof Error ? error : undefined
-    });
-  }
-  static isSilgiError(error) {
-    return error instanceof SilgiError;
-  }
-}
-
-function traverseObject(silgi, obj, currentPath = []) {
-  const uriMap = /* @__PURE__ */ new Map();
-  function traverse(node, path = []) {
-    if (!node || typeof node !== "object")
-      return;
-    if (path.length === 4) {
-      const basePath = path.join("/");
-      let paramString = "";
-      if (node.router) {
-        let params = null;
-        if (node.router?._def?.typeName !== undefined) {
-          try {
-            const shape = node.router?.shape?.params?.shape;
-            params = shape ? Object.keys(shape) : null;
-          } catch {
-            params = null;
-          }
-        }
-        if (params?.length) {
-          paramString = params.map((p) => `:${p}`).join("/");
-        }
-      }
-      uriMap.set(basePath, paramString);
-      return;
-    }
-    for (const key in node) {
-      if (!["_type", "fields"].includes(key)) {
-        traverse(node[key], [...path, key]);
-      }
-    }
-  }
-  traverse(obj, currentPath);
-  return uriMap;
-}
-function parseURI(uri, uris) {
-  if (!uris) {
-    const silgiCtx = useSilgi();
-    uris = silgiCtx.uris;
-  }
-  uri = uri.replace("/srn", "");
-  const [cleanPath, queryString] = uri.split("?");
-  const query = new URLSearchParams(queryString);
-  const methodQuery = query.get("method")?.toLowerCase();
-  const parts = cleanPath.split("/").filter(Boolean);
-  const [namespace, service, methodOrAction, action, ...routerParams] = parts;
-  let uriKey = `${namespace}/${service}/${methodOrAction}/${action}`;
-  if (methodQuery) {
-    uriKey = `${namespace}/${service}/${methodQuery}/${methodOrAction}`;
-    routerParams.unshift(action);
-  }
-  const paramTemplate = uris[uriKey];
-  const routerParamsData = {};
-  if (paramTemplate && routerParams.length > 0) {
-    const paramNames = paramTemplate.split("/").map((p) => p.replace(":", ""));
-    routerParams.forEach((value, index) => {
-      if (paramNames[index]) {
-        routerParamsData[paramNames[index]] = value;
-      }
-    });
-  }
-  return {
-    namespaceName: namespace,
-    serviceName: service,
-    methodName: methodQuery || methodOrAction,
-    actionName: methodQuery ? methodOrAction : action,
-    raw: uri,
-    parts: [namespace, service, methodQuery || methodOrAction, action],
-    routerParams: routerParamsData,
-    query: query.toString() ? Object.fromEntries(query) : undefined,
-    uri: uriKey
-  };
-}
-
-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 useStorage(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 new SilgiError({
-        code: "CACHE_ERROR",
-        message: "Request ID is required for request-scoped cache"
-      });
-    }
-    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 generateSilgiStorageBaseType(silgi) {
-  silgi.hook("prepare:schema.ts", async (options) => {
-    if (silgi.options.storage) {
-      for (const [key, _value] of Object.entries(silgi.options.storage)) {
-        options.storeBase.push(key);
-      }
-    }
-  });
-}
-
-async function generateUris(silgi) {
-  silgi.hook("read:core.ts", async (data) => {
-    const { context, object, path } = await data();
-    const uriMap = traverseObject(silgi, object.schemas, []);
-    if (uriMap.size > 0) {
-      const uriContent = Array.from(uriMap.entries()).map(([uri, params]) => `  '${uri}': '${params}',`).join("\n");
-      const newContext = context.replace(
-        /export const uris = \{[^}]*\}/,
-        `export const uris = {
-${uriContent}
-}`
-      );
-      await promises.writeFile(path, newContext);
-    }
-  });
-}
-async function findAction(silgi, uri) {
-  const { parts } = parseURI(uri, silgi);
-  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 handler = await findAction(silgi, key);
-    silgi.scannedHandlers.set(key, handler);
-  }
-}
-
-async function resolvePath(path, opts = {}) {
-  const _path = path;
-  path = normalize(path);
-  if (isAbsolute(path)) {
-    if (existsSync(path) && !await isDirectory(path)) {
-      return path;
-    }
-  }
-  const cwd = opts.cwd || process.cwd();
-  const extensions = opts.extensions || [".ts", ".mjs", ".cjs", ".json"];
-  const modulesDir = opts.modulesDir || [];
-  path = resolveAlias(path);
-  if (!isAbsolute(path)) {
-    path = resolve(cwd, path);
-  }
-  let _isDir = false;
-  if (existsSync(path)) {
-    _isDir = await isDirectory(path);
-    if (!_isDir) {
-      return path;
-    }
-  }
-  for (const ext of extensions) {
-    const pathWithExt = path + ext;
-    if (existsSync(pathWithExt)) {
-      return pathWithExt;
-    }
-    const pathWithIndex = join(path, `index${ext}`);
-    if (_isDir && existsSync(pathWithIndex)) {
-      return pathWithIndex;
-    }
-  }
-  const resolveModulePath = await resolvePath$1(_path, { url: [cwd, ...modulesDir] }).catch(() => null);
-  if (resolveModulePath) {
-    return resolveModulePath;
-  }
-  return opts.fallbackToOriginal ? _path : path;
-}
-async function isDirectory(path) {
-  return (await promises.lstat(path)).isDirectory();
-}
-function resolveAlias(path, alias) {
-  return resolveAlias$1(path, {});
-}
-function createResolver(base) {
-  if (!base) {
-    throw new Error("`base` argument is missing for createResolver(base)!");
-  }
-  base = base.toString();
-  if (base.startsWith("file://")) {
-    base = dirname(fileURLToPath(base));
-  }
-  return {
-    resolve: (...path) => resolve(base, ...path),
-    resolvePath: (path, opts) => resolvePath(path, { cwd: base, ...opts })
-  };
-}
-async function resolveSilgiModule(base, paths) {
-  const resolved = [];
-  const resolver = createResolver(base);
-  for (const path of paths) {
-    if (path.startsWith(base)) {
-      resolved.push(path.split("/index.ts")[0]);
-    } else {
-      const resolvedPath = await resolver.resolvePath(path);
-      resolved.push(resolvedPath.slice(0, resolvedPath.lastIndexOf(path) + path.length));
-    }
-  }
-  return resolved;
-}
-
-export { SilgiError as S, useStorage as a, SilgiErrorCode as b, createStorage as c, silgiCtx as d, createResolver as e, useHook as f, generateStorageKey as g, useShared as h, getDirectory as i, resolvePath as j, generateUris as k, loadSilgiModuleInstance as l, generateSilgiStorageBaseType as m, normalizeResult as n, parseURI as p, resolveSilgiModule as r, scanAction as s, tryUseSilgi as t, useSilgi as u };