silgi 0.7.0 → 0.7.1

package/dist/core/parser.mjs

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

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

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

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

@@ -0,0 +1,33 @@
+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 };

package/dist/core/uris/utils.mjs

@@ -0,0 +1,127 @@
+import { ErrorFactory, HttpStatus } from '../error.mjs';
+
+function parseURI(uri, uris) {
+  if (!uri) {
+    throw ErrorFactory.create({
+      message: "URI cannot be empty",
+      httpStatus: HttpStatus.BAD_REQUEST,
+      context: { uri }
+    });
+  }
+  if (!uris) {
+    throw ErrorFactory.create({
+      message: "URIs configuration is not provided",
+      httpStatus: HttpStatus.INTERNAL_SERVER_ERROR,
+      context: { uri }
+    });
+  }
+  const cleanUri = uri.replace(/^\/*(srn\/)?/, "").replace(/\/*$/, "");
+  const [path, queryString] = cleanUri.split("?");
+  const parts = path.split("/");
+  const query = queryString ? Object.fromEntries(
+    queryString.split("&").map((param) => param.split("="))
+  ) : void 0;
+  const method = query?.method ? query?.method.toLowerCase() : void 0;
+  const namespaceName = parts[0];
+  const serviceName = parts[1];
+  const methodName = method || parts[2];
+  const actionName = method ? parts[2] : parts[3];
+  if (!namespaceName || !serviceName || !methodName || !actionName) {
+    throw ErrorFactory.create({
+      message: "Invalid URI format: Insufficient path segments",
+      httpStatus: HttpStatus.BAD_REQUEST,
+      context: {
+        uri,
+        cleanUri,
+        partsLength: parts.length,
+        method,
+        namespaceName,
+        serviceName,
+        methodName,
+        actionName
+      }
+    });
+  }
+  const baseUri = `${namespaceName}/${serviceName}/${methodName}/${actionName}`;
+  const paramStartIndex = method ? 3 : 4;
+  const parameters = parts.slice(paramStartIndex);
+  const normalizedUri = method ? `${namespaceName}/${serviceName}/${method}/${actionName}${parameters.length ? `/${parameters.join("/")}` : ""}` : cleanUri;
+  const template = uris[baseUri];
+  if (template === void 0) {
+    throw ErrorFactory.create({
+      message: "No route found for URI",
+      httpStatus: HttpStatus.NOT_FOUND,
+      context: {
+        uri,
+        baseUri
+      }
+    });
+  }
+  if (template === "") {
+    if (parameters.length > 0) {
+      throw ErrorFactory.create({
+        message: "No parameters expected for this route",
+        httpStatus: HttpStatus.BAD_REQUEST,
+        context: {
+          uri,
+          baseUri,
+          extraParams: parameters
+        }
+      });
+    }
+    return {
+      namespaceName,
+      serviceName,
+      methodName,
+      actionName,
+      raw: normalizedUri,
+      parts: [namespaceName, serviceName, methodName, actionName],
+      routerParams: {},
+      query: method ? void 0 : query,
+      uri: baseUri
+    };
+  }
+  const routeTemplate = typeof template === "string" ? template : template.pattern;
+  const validators = typeof template === "string" ? void 0 : template.validators;
+  const routerParams = {};
+  const templateParts = routeTemplate.split("/").filter(Boolean);
+  const paramValues = parameters;
+  let valueIndex = 0;
+  templateParts.forEach((part) => {
+    if (part.startsWith(":")) {
+      const paramName = part.substring(1);
+      const paramValue = paramValues[valueIndex];
+      if (validators?.[paramName] && paramValue) {
+        if (!validators[paramName](paramValue)) {
+          throw ErrorFactory.create({
+            message: "Invalid value for parameter",
+            httpStatus: HttpStatus.UNPROCESSABLE_ENTITY,
+            context: {
+              uri,
+              paramName,
+              paramValue,
+              validatorName: paramName
+            }
+          });
+        }
+      }
+      routerParams[paramName] = paramValue || void 0;
+      valueIndex++;
+    } else if (part && part === paramValues[valueIndex]) {
+      valueIndex++;
+    }
+  });
+  return {
+    namespaceName,
+    serviceName,
+    methodName,
+    actionName,
+    raw: normalizedUri,
+    parts: [namespaceName, serviceName, methodName, actionName],
+    routerParams,
+    query: method ? void 0 : query,
+    uri: baseUri
+  };
+}
+
+export { parseURI };

package/dist/core/utils/event.mjs

@@ -0,0 +1,5 @@
+function getEvent(event) {
+  return event.event || event || {};
+}
+
+export { getEvent };

package/dist/core/utils/global.mjs

@@ -0,0 +1,12 @@
+import { lstatSync } from 'node:fs';
+import { dirname, isAbsolute } from 'pathe';
+
+function getDirectory(p) {
+  try {
+    return isAbsolute(p) && lstatSync(p).isFile() ? dirname(p) : p;
+  } catch {
+  }
+  return p;
+}
+
+export { getDirectory };

package/dist/core/utils/merge.mjs

@@ -0,0 +1,25 @@
+function merge(items, maxLevel = 4, currentLevel = 3) {
+  const arrayItems = Array.isArray(items) ? items : [items];
+  return arrayItems.reduce((acc, item) => {
+    Object.keys(item).forEach((key) => {
+      if (typeof item[key] === "object" && item[key] !== null && currentLevel < maxLevel) {
+        acc[key] = acc[key] || {};
+        acc[key] = merge([acc[key], item[key]], maxLevel, currentLevel + 1);
+      } else {
+        acc[key] = item[key];
+      }
+    });
+    return acc;
+  }, {});
+}
+function mergeSchemas(typesOrArray) {
+  return merge(typesOrArray);
+}
+function mergeServices(servicesOrArray) {
+  return merge(servicesOrArray);
+}
+function mergeShared(sharedOrArray) {
+  return merge(sharedOrArray, 1, 1);
+}
+
+export { mergeSchemas, mergeServices, mergeShared };

package/dist/core/utils/schema.mjs

@@ -0,0 +1,5 @@
+function createSchema(silgiType) {
+  return silgiType;
+}
+
+export { createSchema };

package/dist/core/utils/service.mjs

@@ -0,0 +1,5 @@
+function createService(variables) {
+  return variables;
+}
+
+export { createService };

package/dist/core/utils/shared.mjs

@@ -0,0 +1,5 @@
+function createShared(shared) {
+  return shared;
+}
+
+export { createShared };

package/dist/core/utils/storage.mjs

@@ -0,0 +1,70 @@
+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 { ErrorFactory, HttpStatus } from '../error.mjs';
+import { useSilgi } from '../unctx.mjs';
+
+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 useSilgiStorage(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 ErrorFactory.create({
+        code: HttpStatus.BAD_REQUEST,
+        message: "Request ID is required for request-scoped cache",
+        context: {
+          requestId,
+          operation,
+          input,
+          storageOptions,
+          keyGenerator
+        }
+      });
+    }
+    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");
+}
+
+export { createStorage, generateStorageKey, useSilgiStorage };

package/dist/ecosystem/nitro/index.mjs

@@ -1,62 +1 @@
-import { execSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { resolve, dirname, join } from 'pathe';
-import { loadOptions } from 'silgi/core';
-import { relativeWithDot } from 'silgi/kit';
-import { autoImportTypes } from 'silgi/types';
-
-const module = {
-  name: "silgi",
-  setup: async (nitro) => {
-    const silgiConfig = await loadOptions({});
-    nitro.options.plugins = nitro.options.plugins || [];
-    nitro.options.plugins.push(
-      fileURLToPath(new URL("runtime/plugin", import.meta.url))
-    );
-    const tsConfigPath = resolve(
-      nitro.options.buildDir,
-      nitro.options.typescript.tsconfigPath
-    );
-    const tsconfigDir = dirname(tsConfigPath);
-    nitro.options.typescript.strict = true;
-    nitro.options.typescript.tsConfig ??= {};
-    nitro.options.typescript.tsConfig.extends = "./silgi.tsconfig.json";
-    nitro.options.typescript.tsConfig.include ??= [];
-    nitro.options.typescript.tsConfig.exclude ??= [];
-    if (silgiConfig.typescript.internalPaths || silgiConfig.stub) {
-      nitro.options.alias ||= {};
-      nitro.options.alias = {
-        ...nitro.options.alias,
-        ...silgiConfig.alias
-        // 'silgi/runtime': fileURLToPath(`${new URL(pkgDir, import.meta.url)}dist/runtime/`),
-      };
-    }
-    nitro.options.typescript.tsConfig.include.push(join(relativeWithDot(tsconfigDir, silgiConfig.build.dir), "**/*"));
-    nitro.options.typescript.tsConfig.compilerOptions ??= {};
-    nitro.options.typescript.tsConfig.compilerOptions.paths ??= {};
-    nitro.hooks.hook("types:extend", async () => {
-      const isStub = silgiConfig.stub ? "pnpm silgi prepare --stub" : "pnpm silgi prepare";
-      execSync(isStub, { stdio: "inherit", cwd: nitro.options.rootDir, env: process.env });
-    });
-    nitro.options.exportConditions ??= [];
-    nitro.options.exportConditions.push(...silgiConfig.conditions);
-    if (nitro.options.imports) {
-      nitro.options.imports.dirs ??= [];
-      nitro.options.imports.dirs.push(
-        join(silgiConfig.silgi.serverDir, "**/*")
-      );
-      nitro.options.imports.presets ??= [];
-      nitro.options.imports.presets.push({
-        from: "silgi",
-        imports: ["silgi"]
-      });
-      nitro.options.imports.presets.push({
-        from: "silgi/types",
-        imports: autoImportTypes.map((type) => type),
-        type: true
-      });
-    }
-  }
-};
-
-export { module as default };
+export { default } from './module.mjs';