silgi 0.33.1 → 0.34.0

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-export { BaseError, ErrorCategory, ErrorFactory, ErrorMetadata, ErrorSeverity, HttpStatus, SilgiError, autoImportTypes, createSchema, createService, createShared, createSilgi, createStorage, getEvent, getEventContext, isBaseError, mergeSchemas, mergeServices, mergeShared, parseURI, replaceRuntimeValues, silgi, silgiCLICtx, silgiCtx, storageMount, tryUseSilgi, tryUseSilgiCLI, useSilgi, useSilgiCLI, useSilgiStorage } from './core/index.mjs';
+export { SilgiError, autoImportTypes, createError, createRoute, createSchema, createService, createShared, createSilgi, createSilgiCore, createStorage, deepMergeObjects, getEvent, getEventContext, handleResponse, isError, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, useSilgi, useSilgiCLI, useSilgiStorage } from './core/index.mjs';
 import 'silgi/types';
 import '@standard-schema/spec';
 import 'unstorage';

package/dist/index.mjs

@@ -1,13 +1,13 @@
-export { ErrorCategory, ErrorFactory, ErrorSeverity, HttpStatus, SilgiError, autoImportTypes, createSchema, createService, createShared, createSilgi, createStorage, getEvent, getEventContext, isBaseError, mergeSchemas, mergeServices, mergeShared, parseURI, replaceRuntimeValues, silgi, silgiCtx, storageMount, tryUseSilgi, useSilgi, useSilgiStorage } from './core/index.mjs';
+export { SilgiError, autoImportTypes, createError, createRoute, createSchema, createService, createShared, createSilgi, createSilgiCore, createStorage, deepMergeObjects, getEvent, getEventContext, handleResponse, isError, replaceRuntimeValues, silgiCtx, silgiFetch, storageMount, tryUseSilgi, useSilgi, useSilgiStorage } from './core/index.mjs';
 export { s as silgiCLICtx, t as tryUseSilgiCLI, u as useSilgiCLI } from './_chunks/silgiApp.mjs';
 import 'consola';
 import 'defu';
 import 'hookable';
-import './_chunks/routeRules.mjs';
-import 'ufo';
+import 'rou3';
 import 'unctx';
 import 'node:buffer';
 import 'klona';
 import 'silgi/runtime';
 import 'unstorage';
+import 'srvx';
 import 'silgi/kit';

package/dist/kit/index.d.mts

@@ -1,4 +1,4 @@
-import { Commands, SilgiCLIHooks, GenImport, DefineFrameworkOptions, SilgiCLI, ModuleOptionsCustom, ModuleDefinition, SilgiModule, ServiceParseModule, SilgiPreset, SilgiPresetMeta, SilgiTemplate, ResolvedSilgiTemplate, SilgiEvents } from 'silgi/types';
+import { Commands, SilgiCLIHooks, GenImport, DefineFrameworkOptions, SilgiCLI, ModuleOptionsCustom, ModuleDefinition, SilgiModule, SilgiPreset, SilgiPresetMeta, SilgiTemplate, ResolvedSilgiTemplate, SilgiEvent } from 'silgi/types';
 import { PresetName } from 'silgi/presets';
 import { Buffer } from 'node:buffer';
 import { ConsolaOptions, ConsolaInstance } from 'consola';
@@ -224,32 +224,6 @@ declare function defineSilgiModule<TOptions extends ModuleOptionsCustom>(): {
     with: <TOptionsDefaults extends Partial<TOptions>>(definition: ModuleDefinition<TOptions, TOptionsDefaults, true> | SilgiModule<TOptions, TOptionsDefaults, true>) => SilgiModule<TOptions, TOptionsDefaults, true>;
 };
 
-/**
- *
- *
- * @example
- * srnResorce: 'coreApi.basket.post.createBasket'
- * const { namespace, serviceName, action, method } = cliResorceParse(srnResorce)
- *
- * namespace: 'coreApi'
- * serviceName: 'basket'
- * action: 'post'
- * method: 'createBasket'
- *
- */
-
-declare function serviceParseModule(params: ServiceParseModule): ServiceParseModule;
-declare function parseServices(silgi: SilgiCLI, 
-/**
- * url: /coreApi/basket/post/createBasket
- * pathLength: 4 or [1, 2, 3, 4] to support multiple path depths
- * 1: coreApi
- * 2: basket
- * 3: post
- * 4: createBasket
- */
-pathLength?: number | number[], servicesObject?: Record<string, any>, currentPath?: string[]): Record<string, Record<string, any>>;
-
 declare function prettyPath(p: string, highlight?: boolean): string;
 declare function resolveSilgiPath(path: string, silgiCLIOptions: SilgiCLI['options'], base?: string): string;
 
@@ -301,11 +275,11 @@ declare function addTemplate<T>(_template: SilgiTemplate<T> | string): ResolvedS
  */
 declare function normalizeTemplate<T>(template: SilgiTemplate<T> | string, buildDir?: string): ResolvedSilgiTemplate<T>;
 
-declare function useRequest<T extends IncomingMessage>(event: SilgiEvents): T | (IncomingMessage & {
+declare function useRequest<T extends IncomingMessage>(event: SilgiEvent): T | (IncomingMessage & {
     originalUrl?: string;
 });
-declare function useResponse<T extends ServerResponse>(event: SilgiEvents): ServerResponse;
-declare function getIpAddress(event: SilgiEvents): string | boolean;
+declare function useResponse<T extends ServerResponse>(event: SilgiEvent): ServerResponse;
+declare function getIpAddress(event: SilgiEvent): string | boolean;
 /**
  * Extract the client's IP address from request headers with high accuracy
  * @param req - The incoming HTTP request
@@ -337,5 +311,5 @@ declare function isPresents(names: PresetName[]): boolean;
 declare function isRuntimePresents(names: PresetName[]): boolean;
 declare function removeExtension(filePath: string): string;
 
-export { MODE_RE, MigrationStatus, addCommands, addCoreFile, addImports, addNPMPackage, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineFramework, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, generateMigration, getAllEntries, getIpAddress, getMigration, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory, isH3, isNitro, isNuxt, isPresents, isRuntimePresents, listMigrations, migrationDown, migrationUp, normalizeTemplate, parseServices, prettyPath, processFilePath, relativeWithDot, removeExtension, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, serviceParseModule, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };
+export { MODE_RE, MigrationStatus, addCommands, addCoreFile, addImports, addNPMPackage, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineFramework, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, generateMigration, getAllEntries, getIpAddress, getMigration, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory, isH3, isNitro, isNuxt, isPresents, isRuntimePresents, listMigrations, migrationDown, migrationUp, normalizeTemplate, prettyPath, processFilePath, relativeWithDot, removeExtension, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };
 export type { FunctionConfig, JsonPatch, MigrationData, MigrationInfo, MigrationOptions, MigrationResult };

package/dist/kit/index.mjs

@@ -16,7 +16,6 @@ import { existsSync, promises } from 'node:fs';
 import * as rfc6902 from 'rfc6902';
 import { defu } from 'defu';
 import { c as checkSilgiCompatibility } from '../cli/compatibility.mjs';
-import { withLeadingSlash } from 'ufo';
 import { resolveAlias as resolveAlias$1 } from 'pathe/utils';
 import 'unctx';
 import 'semver/functions/satisfies.js';
@@ -807,59 +806,6 @@ ${issues.toString()}`);
   return silgiNormalizedModule;
 }
 
-function serviceParseModule(params) {
-  return params;
-}
-const parseRouteRules = serviceParseModule(({
-  node,
-  basePath,
-  silgi,
-  pathLength
-}) => {
-  const routeRules = node.routeRules;
-  if (!routeRules)
-    return;
-  let removeMethod = "";
-  removeMethod = withLeadingSlash(basePath);
-  if (pathLength === 1 || pathLength === 2 || pathLength === 3) {
-    if (routeRules.doubleSplat === void 0) {
-      routeRules.doubleSplat = true;
-    }
-  }
-  if (routeRules.splat)
-    removeMethod = `${removeMethod}/*`;
-  else if (routeRules.doubleSplat)
-    removeMethod = `${removeMethod}/**`;
-  removeMethod = removeMethod.replace(/\/{2,}/g, "/");
-  delete routeRules.splat;
-  delete routeRules.doubleSplat;
-  silgi.routeRules.addRule(removeMethod, routeRules);
-});
-function parseServices(silgi, pathLength = [4, 3, 2, 1], servicesObject, currentPath = []) {
-  const modulesURIs = {};
-  silgi.options.serviceParseModules.push(parseRouteRules);
-  const pathLengths = Array.isArray(pathLength) ? pathLength : [pathLength];
-  function traverse(node, path = []) {
-    if (!node || typeof node !== "object")
-      return;
-    if (pathLengths.includes(path.length)) {
-      const basePath = path.join("/");
-      for (const handler of silgi.options.serviceParseModules) {
-        handler({ node, basePath, silgi, modulesURIs, pathLength: path.length });
-      }
-    }
-    for (const key in node) {
-      if (!["_type", "fields"].includes(key)) {
-        traverse(node[key], [...path, key]);
-      }
-    }
-  }
-  traverse(servicesObject || silgi.services, currentPath);
-  silgi.options.serviceParseModules = [];
-  silgi.modulesURIs = defu(modulesURIs, silgi.modulesURIs);
-  return modulesURIs;
-}
-
 function defineSilgiPreset(preset, meta) {
   if (meta?.url && typeof preset !== "function") ;
   return { ...preset, _meta: meta };
@@ -1067,4 +1013,4 @@ function isValidIp(ip) {
   return false;
 }
 
-export { MODE_RE, MigrationStatus, addCommands, addCoreFile, addImports, addNPMPackage, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineFramework, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, generateMigration, getAllEntries, getIpAddress, getMigration, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory$1 as isDirectory, isH3, isNitro, isNuxt, isPresents, isRuntimePresents, listMigrations, migrationDown, migrationUp, normalizeTemplate, parseServices, prettyPath, processFilePath, relativeWithDot, removeExtension, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, serviceParseModule, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };
+export { MODE_RE, MigrationStatus, addCommands, addCoreFile, addImports, addNPMPackage, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineFramework, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, generateMigration, getAllEntries, getIpAddress, getMigration, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory$1 as isDirectory, isH3, isNitro, isNuxt, isPresents, isRuntimePresents, listMigrations, migrationDown, migrationUp, normalizeTemplate, prettyPath, processFilePath, relativeWithDot, removeExtension, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };

package/dist/runtime/internal/config.d.mts

@@ -1,10 +1,10 @@
-import type { EnvOptions, SilgiEvents, SilgiRuntimeConfig } from 'silgi/types';
+import type { EnvOptions, SilgiEvent, SilgiRuntimeConfig } from 'silgi/types';
 /**
  * Access 'resolved' Nuxt runtime configuration, with values updated from environment.
  *
  * This mirrors the runtime behavior of Nitro.
  */
-export declare function useSilgiRuntimeConfig<T extends SilgiRuntimeConfig>(event?: SilgiEvents, inlineRuntimeConfig?: Record<string, any>): SilgiRuntimeConfig;
+export declare function useSilgiRuntimeConfig<T extends SilgiRuntimeConfig>(event?: SilgiEvent, inlineRuntimeConfig?: Record<string, any>): SilgiRuntimeConfig;
 export declare function initRuntimeConfig(envOptions?: EnvOptions, inlineRuntimeConfig?: Record<string, any>): Readonly<Record<string, any>>;
 export declare function updateRuntimeConfig(runtimeConfig: Record<string, unknown>): void;
 export declare function applyEnv(obj: Record<string, any>, opts: EnvOptions, parentKey?: string): Record<string, any>;

package/dist/runtime/internal/next.d.mts

@@ -0,0 +1,4 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import type { Silgi } from 'silgi/types';
+export declare function addNextApp(silgiContext?: Silgi): (req: NextApiRequest | Request, res?: NextApiResponse) => Promise<void | NextApiResponse<any> | Response>;
+export default addNextApp;

package/dist/runtime/internal/next.mjs

@@ -0,0 +1,72 @@
+import { createError, handleResponse, isError, useSilgi } from "silgi";
+import { getQuery, withoutHost } from "ufo";
+export function addNextApp(silgiContext = useSilgi()) {
+  return async (req, res) => {
+    if (!silgiContext) {
+      throw new Error("Silgi context is not defined");
+    }
+    let operation;
+    try {
+      const silgiConnect = silgi({
+        req,
+        res,
+        context: {},
+        url: new URL(req.url || "", "http://localhost")
+      });
+      const query = getQuery(req.url || "");
+      const body = req.body;
+      let newPath = withoutHost(req.url || "").replace(/\/srn/, "");
+      if (newPath.includes("?")) {
+        newPath = `${newPath}&method=${req.method}`;
+      } else {
+        newPath = `${newPath}?method=${req.method}`;
+      }
+      operation = parseURI(newPath, silgiContext.uris);
+      if (!operation) {
+        throw createError({
+          statusCode: 400,
+          statusMessage: "Invalid URI"
+        });
+      }
+      await silgiContext.callHook("event:init", req, {
+        path: newPath,
+        queryParams: query,
+        operation
+      });
+      const data = await silgiConnect.execute(newPath, {
+        ...body
+      }, void 0, query);
+      return handleResponse(data, {
+        req,
+        res,
+        context: {},
+        url: new URL(req.url || "", "http://localhost")
+      }, {
+        debug: false
+      });
+    } catch (err) {
+      if (isError(err)) {
+      }
+      await silgiContext.callHook("execute:error", {
+        error: err instanceof Error ? err : new Error(String(err)),
+        timestamp: Date.now(),
+        operation
+        // event: event as never,
+      });
+      silgiContext.captureError(
+        silgiContext,
+        createError({
+          message: err instanceof Error ? err.message : String(err),
+          statusCode: 500,
+          statusMessage: "Internal Server Error"
+        }),
+        {
+          event,
+          operation,
+          tags: ["execute"]
+        }
+      );
+    }
+  };
+}
+export default addNextApp;

package/dist/runtime/internal/nitro.d.mts

@@ -1,3 +1,3 @@
 import type { Silgi } from 'silgi/types';
-export declare function addNitroApp(silgiCtx?: Silgi): Promise<void>;
+export declare function addNitroApp(silgiContext?: Silgi): Promise<void>;
 export default addNitroApp;

package/dist/runtime/internal/nitro.mjs

@@ -1,66 +1,92 @@
-import { createError, defineEventHandler, getQuery, H3Error, readBody } from "h3";
-import { ErrorFactory, HttpStatus, parseURI, silgi, SilgiError, useSilgi } from "silgi";
-export async function addNitroApp(silgiCtx = useSilgi()) {
-  const nitro = silgiCtx.framework;
-  nitro.router.use("/srn/**", defineEventHandler(async (event) => {
-    let operation;
-    try {
-      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}`;
-      }
-      operation = parseURI(newPath, silgiCtx.uris);
-      if (!operation) {
-        throw ErrorFactory.create({ message: "Invalid URI", httpStatus: HttpStatus.BAD_REQUEST });
-      }
-      await silgiCtx.callHook("event:init", event, {
-        path: newPath,
-        queryParams: query,
-        operation
-      });
-      const data = await silgiConnect.execute(newPath, {
-        ...body
-      }, void 0, query);
-      if (data) {
-        return data;
-      }
-    } catch (err) {
-      if (err instanceof H3Error) {
-        throw err;
-      }
-      if (SilgiError.isError(err)) {
-        throw createError({
-          statusCode: err.httpStatus,
-          message: err.message,
-          data: {
-            code: err.code,
-            category: err.category,
-            severity: err.severity,
-            context: err.context
+import {
+  createError as createH3Error,
+  defineEventHandler,
+  H3Error,
+  readBody
+} from "h3";
+import {
+  createError,
+  isError,
+  silgiFetch,
+  useSilgi
+} from "silgi";
+import { getUrlPrefix } from "../../core/utils/route.ts";
+export async function addNitroApp(silgiContext = useSilgi()) {
+  const nitro = silgiContext.framework;
+  const prefixs = silgiContext.routerPrefixs;
+  for (const prefix of prefixs) {
+    nitro.router.use(`${prefix}/**`, defineEventHandler(async (event) => {
+      const silgiURL = getUrlPrefix(event.path, event.method);
+      try {
+        const resolvedRoute = await silgiFetch(
+          event.path,
+          {
+            method: event.method.toUpperCase(),
+            body: event.method.toUpperCase() === "GET" ? void 0 : await readBody(event).catch(() => void 0)
+          }
+        );
+        if (!resolvedRoute.ok) {
+          await silgiContext.callHook("execute:error", {
+            error: new Error(resolvedRoute.statusText),
+            url: silgiURL,
+            event
+          });
+          silgiContext.captureError(
+            silgiContext,
+            createError({
+              message: resolvedRoute.statusText,
+              statusCode: resolvedRoute.status,
+              statusMessage: resolvedRoute.statusText
+            }),
+            {
+              event,
+              url: silgiURL,
+              tags: ["execute"]
+            }
+          );
+          throw createError({
+            statusCode: resolvedRoute.status,
+            statusMessage: resolvedRoute.statusText
+          });
+        }
+        return resolvedRoute;
+      } catch (err) {
+        if (err instanceof H3Error) {
+          throw err;
+        }
+        if (isError(err)) {
+          throw createH3Error({
+            statusCode: 500,
+            statusMessage: "Internal Server Error",
+            cause: err
+          });
+        }
+        await silgiContext.callHook("execute:error", {
+          error: err instanceof Error ? err : new Error(String(err)),
+          url: silgiURL,
+          event
+        });
+        silgiContext.captureError(
+          silgiContext,
+          createError({
+            message: err instanceof Error ? err.message : String(err),
+            statusCode: 500,
+            statusMessage: "Internal Server Error",
+            cause: err
+          }),
+          {
+            event,
+            url: silgiURL,
+            tags: ["execute"]
           }
+        );
+        throw createError({
+          statusCode: 500,
+          message: "Internal Server Error",
+          cause: err
         });
       }
-      await silgiCtx.callHook("execute:error", {
-        error: err instanceof Error ? err : new Error(String(err)),
-        timestamp: Date.now(),
-        operation,
-        event
-      });
-      silgiCtx.captureError(silgiCtx, SilgiError.from(err), {
-        event,
-        operation,
-        tags: ["execute"]
-      });
-      throw createError({
-        statusCode: 500,
-        message: "Internal Server Error"
-      });
-    }
-  }));
+    }));
+  }
 }
 export default addNitroApp;