silgi 0.3.12 → 0.3.13

package/dist/chunks/generate.mjs

@@ -1,5 +1,5 @@
 import { defineCommand } from 'citty';
-import { r as relativeWithDot, l as loadSilgiConfig } from '../shared/silgi.b9yhSIGd.mjs';
+import { r as relativeWithDot, k as getDirectory, m as resolveSilgiModule, o as resolvePath$1, q as generateUris, v as generateSilgiStorageBaseType, l as loadSilgiConfig } from '../shared/silgi.D2yb1XAa.mjs';
 import { createHooks } from 'hookable';
 import ignore from 'ignore';
 import { isAbsolute, resolve, join, relative, dirname, basename, extname } from 'pathe';
@@ -8,7 +8,6 @@ import { readPackageJSON } from 'pkg-types';
 import { defu } from 'defu';
 import { withTrailingSlash } from 'ufo';
 import { resolvePath, resolve as resolve$1 } from 'mlly';
-import { i as getDirectory, r as resolveSilgiModule, j as resolvePath$1, k as generateUris, m as generateSilgiStorageBaseType } from '../shared/silgi.mBwNj1W0.mjs';
 import { readdir } from 'node:fs/promises';
 import { consola } from 'consola';
 import { globby } from 'globby';
@@ -16,14 +15,14 @@ import { parseSync } from '@oxc-parser/wasm';
 import { createJiti } from 'jiti';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { pascalCase } from 'scule';
-import 'c12';
-import 'untyped';
-import 'std-env';
 import 'node:buffer';
 import 'klona';
 import 'unstorage';
 import 'unstorage/drivers/memory';
 import 'unctx';
+import 'c12';
+import 'untyped';
+import 'std-env';
 import 'pathe/utils';
 
 async function _generateH3DTS(silgi) {

package/dist/cli/index.mjs

@@ -3,7 +3,7 @@ import consola from 'consola';
 
 const name = "silgi";
 const type = "module";
-const version = "0.3.12";
+const version = "0.3.13";
 const packageManager = "pnpm@9.15.1";
 const sideEffects = false;
 const exports = {
@@ -149,6 +149,11 @@ const devDependencies = {
 	vue: "^3.5.13",
 	zod: "^3.24.1"
 };
+const pnpm = {
+	patchedDependencies: {
+		"nitropack@2.10.4": "patches/nitropack@2.10.4.patch"
+	}
+};
 const resolutions = {
 	"@silgi/modules": "workspace:*",
 	silgi: "workspace:*"
@@ -173,6 +178,7 @@ const packageJson = {
 	peerDependenciesMeta: peerDependenciesMeta,
 	dependencies: dependencies,
 	devDependencies: devDependencies,
+	pnpm: pnpm,
 	resolutions: resolutions,
 	publishConfig: publishConfig
 };

package/dist/ecosystem/nitro/index.mjs

@@ -1,9 +1,23 @@
 import { fileURLToPath } from 'node:url';
 import { resolve, dirname, join } from 'pathe';
-import { l as loadSilgiConfig, r as relativeWithDot } from '../../shared/silgi.b9yhSIGd.mjs';
-import 'c12';
+import { types } from '../../index.mjs';
+import { l as loadSilgiConfig, r as relativeWithDot } from '../../shared/silgi.D2yb1XAa.mjs';
+import 'consola';
+import 'defu';
+import 'hookable';
 import 'untyped';
+import 'semver/functions/satisfies.js';
+import 'h3';
+import 'node:fs';
+import 'node:buffer';
+import 'klona';
+import 'unstorage';
+import 'unstorage/drivers/memory';
+import 'unctx';
+import 'c12';
 import 'std-env';
+import 'mlly';
+import 'pathe/utils';
 
 const module = {
   name: "silgi",
@@ -35,6 +49,11 @@ const module = {
         from: "silgi",
         imports: ["silgi"]
       });
+      nitro.options.imports.presets.push({
+        from: "silgi",
+        imports: types.map((type) => type),
+        type: true
+      });
     }
   }
 };

package/dist/ecosystem/nuxt/module.mjs

@@ -1,10 +1,24 @@
 import { defineNuxtModule, createResolver, addImportsDir } from '@nuxt/kit';
 import { resolvePath } from 'mlly';
 import { join } from 'pathe';
-import { l as loadSilgiConfig, r as relativeWithDot } from '../../shared/silgi.b9yhSIGd.mjs';
-import 'c12';
+import { types } from '../../index.mjs';
+import { l as loadSilgiConfig, r as relativeWithDot } from '../../shared/silgi.D2yb1XAa.mjs';
+import 'consola';
+import 'defu';
+import 'hookable';
 import 'untyped';
+import 'semver/functions/satisfies.js';
+import 'h3';
+import 'node:fs';
+import 'node:buffer';
+import 'klona';
+import 'unstorage';
+import 'unstorage/drivers/memory';
+import 'unctx';
+import 'c12';
 import 'std-env';
+import 'node:url';
+import 'pathe/utils';
 
 const module = defineNuxtModule({
   meta: {
@@ -26,6 +40,11 @@ const module = defineNuxtModule({
     nuxt.hook("prepare:types", ({ references }) => {
       references.push({ path: relativeWithDot(nuxt.options.buildDir, join(silgi.buildDir, "silgi.d.ts")) });
     });
+    nuxt.options.imports.presets.push({
+      from: "silgi",
+      imports: types.map((type) => type),
+      type: true
+    });
     addImportsDir(composablesDir);
   }
 });

package/dist/index.d.mts

@@ -193,4 +193,6 @@ declare function createSchema<T extends Partial<Record<keyof DefaultNamespaces,
     };
 };
 
-export { DefaultNamespaces, type ExtendContext, type FetchResponseData, type FilterMethods, MergedSilgiSchema, type MethodOption, type Namespaces, type ParamsOption, type RequestBodyOption, type RouterParams, ServiceType, Silgi, SilgiError, type SilgiFetchClient, SilgiHelper, type SilgiModuleContext, SilgiModuleShared, SilgiOptions, SilgiRouterTypes, SilgiSchema, createResolver, createSchema, createService, createShared, createSilgi, createSilgiFetch, defineSilgiModule, loadSilgiConfig, mergeSchemas, mergeServices, mergeShared, normalizeResult, parseURI, relativeWithDot, silgiCtx, silgiFetchRequestInterceptor, tryUseSilgi, useHook, useShared, useSilgi };
+declare const types: string[];
+
+export { DefaultNamespaces, type ExtendContext, type FetchResponseData, type FilterMethods, MergedSilgiSchema, type MethodOption, type Namespaces, type ParamsOption, type RequestBodyOption, type RouterParams, ServiceType, Silgi, SilgiError, type SilgiFetchClient, SilgiHelper, type SilgiModuleContext, SilgiModuleShared, SilgiOptions, SilgiRouterTypes, SilgiSchema, createResolver, createSchema, createService, createShared, createSilgi, createSilgiFetch, defineSilgiModule, loadSilgiConfig, mergeSchemas, mergeServices, mergeShared, normalizeResult, parseURI, relativeWithDot, silgiCtx, silgiFetchRequestInterceptor, tryUseSilgi, types, useHook, useShared, useSilgi };

package/dist/index.d.ts

@@ -193,4 +193,6 @@ declare function createSchema<T extends Partial<Record<keyof DefaultNamespaces,
     };
 };
 
-export { DefaultNamespaces, type ExtendContext, type FetchResponseData, type FilterMethods, MergedSilgiSchema, type MethodOption, type Namespaces, type ParamsOption, type RequestBodyOption, type RouterParams, ServiceType, Silgi, SilgiError, type SilgiFetchClient, SilgiHelper, type SilgiModuleContext, SilgiModuleShared, SilgiOptions, SilgiRouterTypes, SilgiSchema, createResolver, createSchema, createService, createShared, createSilgi, createSilgiFetch, defineSilgiModule, loadSilgiConfig, mergeSchemas, mergeServices, mergeShared, normalizeResult, parseURI, relativeWithDot, silgiCtx, silgiFetchRequestInterceptor, tryUseSilgi, useHook, useShared, useSilgi };
+declare const types: string[];
+
+export { DefaultNamespaces, type ExtendContext, type FetchResponseData, type FilterMethods, MergedSilgiSchema, type MethodOption, type Namespaces, type ParamsOption, type RequestBodyOption, type RouterParams, ServiceType, Silgi, SilgiError, type SilgiFetchClient, SilgiHelper, type SilgiModuleContext, SilgiModuleShared, SilgiOptions, SilgiRouterTypes, SilgiSchema, createResolver, createSchema, createService, createShared, createSilgi, createSilgiFetch, defineSilgiModule, loadSilgiConfig, mergeSchemas, mergeServices, mergeShared, normalizeResult, parseURI, relativeWithDot, silgiCtx, silgiFetchRequestInterceptor, tryUseSilgi, types, useHook, useShared, useSilgi };

package/dist/index.mjs

@@ -2,11 +2,9 @@ import { createConsola } from 'consola';
 import defu, { defu as defu$1 } from 'defu';
 import { createHooks } from 'hookable';
 import { applyDefaults } from 'untyped';
-import { u as useSilgi, l as loadSilgiModuleInstance, p as parseURI, S as SilgiError, a as useStorage, n as normalizeResult, b as SilgiErrorCode, g as generateStorageKey, s as scanAction, c as createStorage, d as silgiCtx, t as tryUseSilgi } from './shared/silgi.mBwNj1W0.mjs';
-export { e as createResolver, f as useHook, h as useShared } from './shared/silgi.mBwNj1W0.mjs';
+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 { S as SilgiConfigSchema } from './shared/silgi.b9yhSIGd.mjs';
-export { l as loadSilgiConfig, r as relativeWithDot } from './shared/silgi.b9yhSIGd.mjs';
 import { defineEventHandler, getQuery, readBody } from 'h3';
 import 'node:fs';
 import 'pathe';
@@ -15,11 +13,11 @@ import 'klona';
 import 'unstorage';
 import 'unstorage/drivers/memory';
 import 'unctx';
+import 'c12';
+import 'std-env';
 import 'node:url';
 import 'mlly';
 import 'pathe/utils';
-import 'c12';
-import 'std-env';
 
 const SEMANTIC_VERSION_RE = /-\d+\.[0-9a-f]+/;
 function normalizeSemanticVersion(version) {
@@ -496,4 +494,10 @@ function createSchema(silgiType) {
   return silgiType;
 }
 
-export { SilgiError, SilgiHelper, createSchema, createService, createShared, createSilgi, createSilgiFetch, defineSilgiModule, mergeSchemas, mergeServices, mergeShared, normalizeResult, parseURI, silgi, silgiCtx, silgiFetchRequestInterceptor, tryUseSilgi, useSilgi };
+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 };

package/dist/shared/{silgi.b9yhSIGd.mjs → silgi.D2yb1XAa.mjs}

@@ -1,7 +1,71 @@
+import { lstatSync, promises, existsSync } from 'node:fs';
+import { isAbsolute, dirname, resolve, join, relative, basename, normalize } 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 { loadConfig } from 'c12';
 import { defineUntypedSchema, applyDefaults } from 'untyped';
-import { resolve, join, relative, basename } from 'pathe';
 import { isDevelopment, isTest, isDebug } from 'std-env';
+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 };
+}
 
 const common = defineUntypedSchema({
   /**
@@ -431,6 +495,254 @@ const SilgiConfigSchema = {
   ...typescript
 };
 
+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 loadSilgiConfig(opts) {
   globalThis.defineSilgiConfig = (c) => c;
   const result = await loadConfig({
@@ -451,9 +763,80 @@ async function loadSilgiConfig(opts) {
   return await applyDefaults(SilgiConfigSchema, silgiConfig);
 }
 
+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;
+}
+
 const RELATIVE_RE = /^([^.])/;
 function relativeWithDot(from, to) {
   return relative(from, to).replace(RELATIVE_RE, "./$1") || ".";
 }
 
-export { SilgiConfigSchema as S, loadSilgiConfig as l, relativeWithDot as r };
+export { SilgiError as S, loadSilgiModuleInstance as a, useStorage as b, SilgiErrorCode as c, SilgiConfigSchema as d, createStorage as e, silgiCtx as f, generateStorageKey as g, createResolver as h, useHook as i, useShared as j, getDirectory as k, loadSilgiConfig as l, resolveSilgiModule as m, normalizeResult as n, resolvePath as o, parseURI as p, generateUris as q, relativeWithDot as r, scanAction as s, tryUseSilgi as t, useSilgi as u, generateSilgiStorageBaseType as v };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.3.12",
+  "version": "0.3.13",
   "sideEffects": false,
   "exports": {
     ".": {

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 };