silgi 0.4.12 → 0.5.0

package/dist/runtime/internal/nitro.mjs

@@ -1,44 +1,55 @@
-import { createError, defineEventHandler, getQuery, readBody } from "h3";
+import { createError, defineEventHandler, getQuery, H3Error, readBody, setResponseStatus } from "h3";
 import { silgi, SilgiError, useSilgi } from "silgi/core";
 export default async function addNitroApp(silgiCtx = useSilgi()) {
   const nitro = silgiCtx.framework;
-  nitro.router.use("/srn/**", defineEventHandler({
-    handler: async (event) => {
+  nitro.router.use("/srn/**", defineEventHandler(async (event) => {
+    try {
       const ctx = useSilgi();
-      if (ctx.options.environment === "nitrojs" || ctx.options.environment === "h3") {
-        const silgiConnect = silgi(event);
-        const query = getQuery(event);
-        const body = await readBody(event).catch(() => {
+      if (ctx.options.environment !== "nitrojs" && ctx.options.environment !== "h3") {
+        event.node.res.statusCode = 400;
+        return createError({
+          statusCode: 400,
+          statusMessage: "Bad Request"
         });
-        let newPath = event.path;
-        if (event.path.includes("?")) {
-          newPath = `${event.path}&method=${event.method}`;
-        } else {
-          newPath = `${event.path}?method=${event.method}`;
-        }
-        try {
-          const data = await silgiConnect.execute(newPath, {
-            ...query,
-            ...body
-          });
-          if (data.success) {
-            return data.data;
-          }
-        } catch (error) {
-          if (error instanceof SilgiError && error.code.startsWith("URI_PARSE_ERROR")) {
-            throw createError({
-              statusCode: 400,
-              message: error.message
-            });
+      }
+      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
+      });
+      if (data) {
+        return data;
+      }
+    } catch (error) {
+      if (error instanceof H3Error) {
+        setResponseStatus(event, error.statusCode);
+        throw createError({
+          statusCode: error.statusCode,
+          message: error.message,
+          data: error.data
+          // unhandled: false,
+          // fatal: false,
+        });
+      }
+      if (SilgiError.isError(error)) {
+        throw createError({
+          statusCode: error.httpStatus,
+          message: error.message,
+          data: {
+            code: error.code,
+            category: error.category,
+            severity: error.severity,
+            context: error.context
           }
-          throw error;
-        }
-        return {
-          path: event.path,
-          method: event.method,
-          body,
-          query
-        };
+        });
       }
     }
   }));

package/dist/shared/{silgi.yr8vHHvd.d.ts → silgi.CN_giHTc.d.mts}

@@ -2,19 +2,18 @@ import { Defu } from 'defu';
 import { TypeSource, IResolvers } from '@graphql-tools/utils';
 import { TSConfig } from 'pkg-types';
 import { StandardSchemaV1 } from '@standard-schema/spec';
-import { ConsolaOptions, ConsolaInstance, LogLevel } from 'consola';
+import { LogLevel, ConsolaInstance } from 'consola';
 import { Hookable } from 'hookable';
-import { Ignore, Options } from 'ignore';
+import { Options, Ignore } from 'ignore';
 import { PresetOptions, PresetName, PresetNameInput } from 'silgi/presets';
-import { StorageMounts as StorageMounts$1, SilgiFrameworkInfo as SilgiFrameworkInfo$1, ResolvedServiceType as ResolvedServiceType$1, SilgiDefaultShared as SilgiDefaultShared$1, SilgiModules as SilgiModules$1, ModuleMeta as ModuleMeta$1 } from 'silgi/types';
+import { StorageMounts, SilgiFrameworkInfo as SilgiFrameworkInfo$1, ResolvedServiceType, SilgiDefaultShared, SilgiModules as SilgiModules$1, ModuleMeta as ModuleMeta$1 } from 'silgi/types';
 import { Unimport } from 'unimport';
-import { BuiltinDriverName, TransactionOptions, Storage } from 'unstorage';
+import { Storage } from 'unstorage';
 import { ResolvedConfig, ConfigWatcher, C12InputConfig, WatchConfigOptions } from 'c12';
 import { ChokidarOptions } from 'chokidar';
 import { DateString, CompatibilityDates, CompatibilityDateSpec } from 'compatx';
 import { UnimportPluginOptions } from 'unimport/unplugin';
 import { ProviderName } from 'std-env';
-import { s as silgi, u as useStorage } from './silgi.40ZJYm8F.js';
 
 type HookResult = Promise<void> | void;
 
@@ -29,12 +28,6 @@ interface SilgiCompatibilityIssues extends Array<SilgiCompatibilityIssue> {
     toString: () => string;
 }
 
-/**
- * Bu nitrojs, h3 event or request context.
- */
-interface SilgiEvent extends Record<string, unknown> {
-}
-
 interface SilgiSchema {
 }
 interface MergedSilgiSchema {
@@ -86,256 +79,6 @@ type ExtractInputFromURI<TURI extends keyof SilgiURIs> = GetInput<ExtractPath<TU
 type ExtractOutputFromURI<TURI extends keyof SilgiURIs> = GetOutput<ExtractPath<TURI>>;
 type ExtractRouterParamsFromURI<TURI extends keyof SilgiURIs> = GetRouterParams<ExtractPath<TURI>>;
 
-/**
- * @example
- * namespace: 'coreApi'
- * serviceName: 'basket'
- * method: 'post'
- * action: 'createBasket'
- */
-interface SilgiOperation {
-    /**
-     * 'coreApi'
-     * 'storageApi'
-     */
-    namespaceName: keyof DefaultNamespaces;
-    /**
-     * 'basket'
-     * 'user'
-     */
-    serviceName: string;
-    /**
-     * 'post'
-     * 'delete'
-     */
-    methodName: string;
-    /**
-     * 'createBasket'
-     * 'deleteUser'
-     */
-    actionName: string;
-    /**
-     * 'coreApi/basket/post/createBasket'
-     */
-    raw: string;
-    /**
-     * '/book/basket/getAllBaskets'
-     */
-    uri: keyof SilgiURIs;
-    /**
-     * ['coreApi', 'book', 'basket', 'getAllBaskets']
-     */
-    parts: string[];
-    /**
-     * {id: '123', name: 'John', bookId: '456', authorId: '789'}
-     */
-    routerParams?: Record<string, string | undefined>;
-    /**
-     * url ?limit=10&page=1
-     * {limit: '10', page: '1'}
-     */
-    query?: Record<string, string>;
-}
-
-type CustomDriverName = string & {
-    _custom?: any;
-};
-interface StorageMounts {
-    [path: string]: {
-        driver: BuiltinDriverName | CustomDriverName;
-        [option: string]: any;
-    };
-}
-interface SilgiStorageBase {
-}
-type StorageKeyGenerator<TInput> = (input: TInput) => string | Promise<string>;
-interface StorageConfig<TInput> {
-    options: TransactionOptions;
-    base: '/memory:cache' | keyof SilgiStorageBase;
-    key?: StorageKeyGenerator<TInput>;
-    scope?: 'request' | 'global';
-}
-interface StorageKeyParams<TInput = unknown> {
-    operation: SilgiOperation;
-    input: TInput;
-    requestId?: string;
-    keyGenerator?: StorageKeyGenerator<TInput>;
-    storageOptions?: Pick<StorageConfig<TInput>, 'base' | 'options' | 'scope'>;
-}
-
-interface SilgiOptions {
-    consolaOptions?: Partial<ConsolaOptions>;
-    builder: 'nuxt' | 'nitrojs';
-    /**
-     * Set to `true` to enable debug mode.
-     *
-     * At the moment, it prints out hook names and timings on the server, and logs hook arguments as well in the browser.
-     *
-     * @default false
-     */
-    debug: boolean;
-    storage: StorageMounts;
-    [key: string]: any;
-}
-
-interface SilgiAppPlugin {
-    (silgi: Silgi): Promise<void> | void;
-}
-
-interface CapturedErrorContext {
-    event?: SilgiEvent;
-    [key: string]: unknown;
-}
-type CaptureError = (error: Error, context: CapturedErrorContext) => void;
-
-/**
- * The listeners to Silgi
- */
-interface SilgiHooks {
-    /**
-     * Called after Silgi initialization, when the Silgi instance is ready to work.
-     * @param silgi The configured Silgi object
-     * @returns Promise
-     */
-    'ready': (silgi: Silgi) => HookResult;
-    /**
-     * Called when silgi instance is gracefully closing.
-     * @param silgi The configured silgi object
-     * @returns Promise
-     */
-    'close': (silgi: Silgi) => HookResult;
-    'app:setup:start': (silgi: Silgi) => HookResult;
-    'action:before': (context: ModuleHookContext) => HookResult;
-    'action:after': (context: ModuleHookContext) => HookResult;
-    'action:error': (context: ModuleHookContext) => HookResult;
-    'action:finally': (context: ModuleHookContext) => HookResult;
-    'event:before': (event: SilgiEvent) => HookResult;
-    'error': CaptureError;
-}
-
-type SilgiServiceInterface<T extends BaseSchemaType<StandardSchemaV1>> = {
-    [Action in keyof T]: T[Action] extends Record<string, any> ? {
-        [Method in keyof T[Action]]: {
-            input: T[Action][Method]['input'];
-            output: T[Action][Method]['output'];
-            router: T[Action][Method]['router'];
-        };
-    } : never;
-};
-type ServiceType<T> = Partial<{
-    [Namespace in keyof T]: T[Namespace] extends Record<string, any> ? {
-        [Service in keyof T[Namespace]]?: MethodHandlerType<T[Namespace][Service]>;
-    } : never;
-}>;
-type RequiredServiceType<T> = {
-    [K in keyof T]-?: T[K] extends Record<string, any> ? {
-        [P in keyof T[K]]-?: MethodHandlerType<T[K][P]>;
-    } : never;
-};
-/**
- * const test: ResolvedServiceType = {
-  aaa: {
-    bbb: {
-      delete: {
-        storage: {
-          handler: () => {}
-        },
-      },
-    },
-  },
-}
- */
-type ResolvedServiceType = {
-    [K in string]: {
-        [P in string]: {
-            [Q in BaseSilgiMethodType]?: {
-                [M in string]: ResolvedMethodHandlerType;
-            };
-        };
-    };
-};
-
-interface FrameworkContext {
-}
-interface Silgi {
-    schemas: any;
-    services: ResolvedServiceType;
-    shared: SilgiDefaultShared;
-    uris: Record<string, any>;
-    modulesURIs: Partial<Record<keyof SilgiModules, any>>;
-    scannedHandlers: Map<string, ResolvedMethodHandlerType>;
-    plugins: SilgiAppPlugin[];
-    framework: FrameworkContext;
-    _ignore?: Ignore;
-    hooks: Hookable<SilgiHooks & DefaultHooks>;
-    hook: Silgi['hooks']['hook'];
-    callHook: Silgi['hooks']['callHook'];
-    addHooks: Silgi['hooks']['addHooks'];
-    ready: () => Promise<void>;
-    close: () => Promise<void>;
-    logger: ConsolaInstance;
-    storage: Storage;
-    options: SilgiOptions & SilgiModuleOptions;
-    captureError: CaptureError;
-}
-interface SilgiConfig extends Pick<Silgi, 'services' | 'shared' | 'uris' | 'schemas' | 'modulesURIs' | 'plugins' | 'framework'>, Partial<SilgiModuleOptions> {
-    options: DeepPartial<SilgiOptions>;
-}
-type SilgiFunction = typeof silgi;
-
-interface SilgiDefaultShared extends SilgiModuleShared {
-    storage: (...data: Parameters<typeof useStorage>) => ReturnType<typeof useStorage>;
-    silgi: SilgiFunction;
-}
-interface SilgiModuleShared {
-}
-interface ExtendShared {
-}
-
-interface MethodSchemaType<Input, Output> {
-    default: {
-        input?: Input;
-        output: Output;
-    };
-    handler: (input: Input, shared: SilgiDefaultShared, event: SilgiEvent) => Promise<Output>;
-    modules?: Partial<ModuleConfigurations>;
-    storage?: StorageConfig<Input>;
-}
-type EventHandlerResponse<T = undefined> = T extends undefined ? void : void | T | Promise<T>;
-type MethodHandlerType<T> = {
-    [Action in keyof T]: T[Action] extends Record<string, any> ? {
-        [Method in keyof T[Action]]: {
-            default?: {
-                input?: StandardSchemaV1.InferInput<T[Action][Method]['input']>;
-                output?: StandardSchemaV1.InferInput<T[Action][Method]['output']>;
-            };
-            handler: (router: StandardSchemaV1.InferInput<T[Action][Method]['router']>, input: StandardSchemaV1.InferInput<T[Action][Method]['input']>, shared: SilgiDefaultShared, event: SilgiEvent) => EventHandlerResponse<StandardSchemaV1.InferOutput<T[Action][Method]['output']>>;
-            modules?: Partial<ModuleConfigurations>;
-            storage?: StorageConfig<T[Action][Method]['input']>;
-        };
-    } : never;
-};
-interface ResolvedMethodHandlerType {
-    input?: Partial<BaseSchemaType<any>>;
-    output: Partial<BaseSchemaType<any>>;
-    handler: (router: StandardSchemaV1.InferInput<any>, input: StandardSchemaV1.InferInput<any>, shared: SilgiDefaultShared, event: SilgiEvent) => Promise<StandardSchemaV1.InferInput<any>>;
-    modules?: Partial<ModuleConfigurations>;
-    storage?: StorageConfig<StandardSchemaV1.InferInput<any>>;
-    execute: (input: StandardSchemaV1.InferInput<any>, shared: SilgiDefaultShared, event: SilgiEvent) => Promise<StandardSchemaV1.InferInput<any>>;
-}
-type MethodResponse<T> = {
-    success: true;
-    data: T;
-    cached?: boolean;
-} | {
-    success: false;
-    error: {
-        code: string;
-        message: string;
-        details?: Record<string, unknown>;
-    };
-};
-
 interface SilgiMethods {
 }
 interface SilgiNamespaces {
@@ -354,7 +97,7 @@ type DeepPartial<T> = T extends void ? T : T extends Record<string, any> ? {
 } : T;
 type Awaitable<T> = T | Promise<T>;
 interface CreateScope {
-    execute: <TURI extends keyof SilgiURIs>(uriString: TURI, input: ExtractInputFromURI<TURI>) => Promise<MethodResponse<ExtractOutputFromURI<TURI>>>;
+    execute: <TURI extends keyof SilgiURIs>(uriString: TURI, input: ExtractInputFromURI<TURI>) => Promise<ExtractOutputFromURI<TURI>>;
 }
 
 type SilgiPreset = SilgiCLIConfig | (() => SilgiCLIConfig);
@@ -391,8 +134,8 @@ interface SilgiCLIOptions extends PresetOptions {
     logLevel: LogLevel;
     appConfig: AppConfig;
     appConfigFiles: string[];
-    storage: StorageMounts$1;
-    devStorage: StorageMounts$1;
+    storage: StorageMounts;
+    devStorage: StorageMounts;
     workspaceDir: string;
     rootDir: string;
     srcDir: string;
@@ -574,8 +317,8 @@ interface ImportItem {
 }
 interface SilgiCLI {
     _ignore?: Ignore;
-    services: ResolvedServiceType$1;
-    shareds: SilgiDefaultShared$1;
+    services: ResolvedServiceType;
+    shareds: SilgiDefaultShared;
     uris: Record<string, any>;
     schemas: Record<string, any>;
     modulesURIs: Partial<Record<keyof SilgiModules$1, any>>;
@@ -721,6 +464,63 @@ interface SilgiCLIHooks {
     }) => HookResult;
 }
 
+/**
+ * Bu nitrojs, h3 event or request context.
+ */
+interface SilgiEvent extends Record<string, unknown> {
+}
+
+/**
+ * @example
+ * namespace: 'coreApi'
+ * serviceName: 'basket'
+ * method: 'post'
+ * action: 'createBasket'
+ */
+interface SilgiOperation {
+    /**
+     * 'coreApi'
+     * 'storageApi'
+     */
+    namespaceName: keyof DefaultNamespaces;
+    /**
+     * 'basket'
+     * 'user'
+     */
+    serviceName: string;
+    /**
+     * 'post'
+     * 'delete'
+     */
+    methodName: string;
+    /**
+     * 'createBasket'
+     * 'deleteUser'
+     */
+    actionName: string;
+    /**
+     * 'coreApi/basket/post/createBasket'
+     */
+    raw: string;
+    /**
+     * '/book/basket/getAllBaskets'
+     */
+    uri: keyof SilgiURIs;
+    /**
+     * ['coreApi', 'book', 'basket', 'getAllBaskets']
+     */
+    parts: string[];
+    /**
+     * {id: '123', name: 'John', bookId: '456', authorId: '789'}
+     */
+    routerParams?: Record<string, string | undefined>;
+    /**
+     * url ?limit=10&page=1
+     * {limit: '10', page: '1'}
+     */
+    query?: Record<string, string>;
+}
+
 interface SilgiModules {
 }
 interface SilgiModuleMethods {
@@ -831,4 +631,4 @@ interface SilgiModule<TOptions extends ModuleOptions = ModuleOptions, TOptionsDe
 }
 type ModuleConfigurations = SilgiModuleMethods;
 
-export type { ResolvedServiceType as $, AppConfig as A, BaseSchemaType as B, CreateScope as C, DefaultNamespaces as D, ModuleSetupReturn as E, SilgiModule as F, ModuleConfigurations as G, SilgiOperation as H, SilgiPreset as I, SilgiPresetMeta as J, MethodSchemaType as K, LoadConfigOptions as L, ModuleMeta as M, EventHandlerResponse as N, MethodHandlerType as O, ResolvedMethodHandlerType as P, MethodResponse as Q, ResolvedModuleMeta as R, SilgiServiceInterface as S, TSReference as T, SilgiAppPlugin as U, CapturedErrorContext as V, CaptureError as W, SilgiSchema as X, MergedSilgiSchema as Y, ServiceType as Z, RequiredServiceType as _, SilgiCLIOptions as a, SilgiDefaultShared as a0, SilgiModuleShared as a1, ExtendShared as a2, FrameworkContext as a3, Silgi as a4, SilgiConfig as a5, SilgiFunction as a6, ImportItem as a7, SilgiCLI as a8, SilgiCLIDynamicConfig as a9, SilgiFrameworkInfo as aa, NitroBuildInfo as ab, SilgiURIs as ac, URIsTypes as ad, ExtractInputFromURI as ae, ExtractOutputFromURI as af, ExtractRouterParamsFromURI as ag, StorageMounts as ah, SilgiStorageBase as ai, StorageKeyGenerator as aj, StorageConfig as ak, StorageKeyParams as al, SilgiCLIConfig as b, SilgiCLIHooks as c, SilgiCompatibilityIssue as d, SilgiCompatibilityIssues as e, SilgiOptions as f, SilgiEvent as g, SilgiMethods as h, SilgiNamespaces as i, SilgiRouterTypes as j, SilgiHook as k, BaseSilgiMethodType as l, DefaultHooks as m, DeepPartial as n, Awaitable as o, SilgiHooks as p, SilgiModules as q, SilgiModuleMethods as r, SilgiModuleOptions as s, SilgiModuleInput as t, SilgiCompatibility as u, ModuleHookContext as v, ModuleOptions as w, ResolvedModuleOptions as x, ModuleDefinition as y, ModuleSetupInstallResult as z };
+export type { AppConfig as A, BaseSchemaType as B, CreateScope as C, DefaultHooks as D, ModuleSetupReturn as E, SilgiPreset as F, SilgiPresetMeta as G, HookResult as H, SilgiSchema as I, MergedSilgiSchema as J, ImportItem as K, LoadConfigOptions as L, ModuleOptions as M, SilgiCLI as N, SilgiCLIDynamicConfig as O, SilgiFrameworkInfo as P, NitroBuildInfo as Q, ResolvedModuleMeta as R, SilgiModule as S, TSReference as T, SilgiURIs as U, URIsTypes as V, ExtractInputFromURI as W, ExtractOutputFromURI as X, ExtractRouterParamsFromURI as Y, ModuleDefinition as a, SilgiOperation as b, SilgiEvent as c, ModuleConfigurations as d, BaseSilgiMethodType as e, SilgiModules as f, SilgiModuleOptions as g, DeepPartial as h, ModuleHookContext as i, DefaultNamespaces as j, SilgiCLIOptions as k, SilgiCLIConfig as l, SilgiCLIHooks as m, SilgiCompatibilityIssue as n, SilgiCompatibilityIssues as o, SilgiMethods as p, SilgiNamespaces as q, SilgiRouterTypes as r, SilgiHook as s, Awaitable as t, SilgiModuleMethods as u, SilgiModuleInput as v, SilgiCompatibility as w, ModuleMeta as x, ResolvedModuleOptions as y, ModuleSetupInstallResult as z };