silgi 0.4.12 → 0.5.0

package/dist/types/index.d.ts

@@ -1,22 +1,63 @@
-import { D as DefaultNamespaces, B as BaseSchemaType, S as SilgiServiceInterface } from '../shared/silgi.yr8vHHvd.js';
-export { A as AppConfig, o as Awaitable, l as BaseSilgiMethodType, W as CaptureError, V as CapturedErrorContext, C as CreateScope, n as DeepPartial, m as DefaultHooks, N as EventHandlerResponse, a2 as ExtendShared, ae as ExtractInputFromURI, af as ExtractOutputFromURI, ag as ExtractRouterParamsFromURI, a3 as FrameworkContext, a7 as ImportItem, L as LoadConfigOptions, Y as MergedSilgiSchema, O as MethodHandlerType, Q as MethodResponse, K as MethodSchemaType, G as ModuleConfigurations, y as ModuleDefinition, v as ModuleHookContext, M as ModuleMeta, w as ModuleOptions, z as ModuleSetupInstallResult, E as ModuleSetupReturn, ab as NitroBuildInfo, _ as RequiredServiceType, P as ResolvedMethodHandlerType, R as ResolvedModuleMeta, x as ResolvedModuleOptions, $ as ResolvedServiceType, Z as ServiceType, a4 as Silgi, U as SilgiAppPlugin, a8 as SilgiCLI, b as SilgiCLIConfig, a9 as SilgiCLIDynamicConfig, c as SilgiCLIHooks, a as SilgiCLIOptions, u as SilgiCompatibility, d as SilgiCompatibilityIssue, e as SilgiCompatibilityIssues, a5 as SilgiConfig, a0 as SilgiDefaultShared, g as SilgiEvent, aa as SilgiFrameworkInfo, a6 as SilgiFunction, k as SilgiHook, p as SilgiHooks, h as SilgiMethods, F as SilgiModule, t as SilgiModuleInput, r as SilgiModuleMethods, s as SilgiModuleOptions, a1 as SilgiModuleShared, q as SilgiModules, i as SilgiNamespaces, H as SilgiOperation, f as SilgiOptions, I as SilgiPreset, J as SilgiPresetMeta, j as SilgiRouterTypes, X as SilgiSchema, ai as SilgiStorageBase, ac as SilgiURIs, ak as StorageConfig, aj as StorageKeyGenerator, al as StorageKeyParams, ah as StorageMounts, T as TSReference, ad as URIsTypes } from '../shared/silgi.yr8vHHvd.js';
+import { b as SilgiOperation, c as SilgiEvent, d as ModuleConfigurations, B as BaseSchemaType, e as BaseSilgiMethodType, f as SilgiModules, D as DefaultHooks, g as SilgiModuleOptions, h as DeepPartial, H as HookResult, i as ModuleHookContext, j as DefaultNamespaces } from '../shared/silgi.CN_giHTc.js';
+export { A as AppConfig, t as Awaitable, C as CreateScope, W as ExtractInputFromURI, X as ExtractOutputFromURI, Y as ExtractRouterParamsFromURI, K as ImportItem, L as LoadConfigOptions, J as MergedSilgiSchema, a as ModuleDefinition, x as ModuleMeta, M as ModuleOptions, z as ModuleSetupInstallResult, E as ModuleSetupReturn, Q as NitroBuildInfo, R as ResolvedModuleMeta, y as ResolvedModuleOptions, N as SilgiCLI, l as SilgiCLIConfig, O as SilgiCLIDynamicConfig, m as SilgiCLIHooks, k as SilgiCLIOptions, w as SilgiCompatibility, n as SilgiCompatibilityIssue, o as SilgiCompatibilityIssues, P as SilgiFrameworkInfo, s as SilgiHook, p as SilgiMethods, S as SilgiModule, v as SilgiModuleInput, u as SilgiModuleMethods, q as SilgiNamespaces, F as SilgiPreset, G as SilgiPresetMeta, r as SilgiRouterTypes, I as SilgiSchema, U as SilgiURIs, T as TSReference, V as URIsTypes } from '../shared/silgi.CN_giHTc.js';
+import { ConsolaOptions, ConsolaInstance } from 'consola';
+import { PresetNameInput } from 'silgi/presets';
+import { BuiltinDriverName, TransactionOptions, Storage } from 'unstorage';
+import { Hookable } from 'hookable';
+import { Ignore } from 'ignore';
+import { u as useStorage, s as silgi } from '../shared/silgi.DGmIWx95.js';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import 'defu';
 import '@graphql-tools/utils';
 import 'pkg-types';
-import 'consola';
-import 'hookable';
-import 'ignore';
-import 'silgi/presets';
 import 'silgi/types';
 import 'unimport';
-import 'unstorage';
 import 'c12';
 import 'chokidar';
 import 'compatx';
 import 'unimport/unplugin';
 import 'std-env';
-import '../shared/silgi.40ZJYm8F.js';
+
+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>;
+    present: PresetNameInput;
+    /**
+     * 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 SilgiModuleContext extends Record<string, any> {
 }
@@ -31,6 +72,152 @@ interface GraphQLJSON {
     references: any;
 }
 
+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 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 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;
+}
+
 interface BaseNamespaceType extends Record<keyof DefaultNamespaces, Record<string, BaseSchemaType<StandardSchemaV1>>> {
 }
 type Namespaces<T extends BaseNamespaceType> = {
@@ -41,4 +228,4 @@ type Namespaces<T extends BaseNamespaceType> = {
 
 declare const autoImportTypes: string[];
 
-export { type BaseNamespaceType, BaseSchemaType, DefaultNamespaces, type ExtendContext, type GraphQLJSON, type Namespaces, type SilgiModuleContext, SilgiServiceInterface, autoImportTypes };
+export { type BaseNamespaceType, BaseSchemaType, BaseSilgiMethodType, type CaptureError, type CapturedErrorContext, DeepPartial, DefaultHooks, DefaultNamespaces, type EventHandlerResponse, type ExtendContext, type ExtendShared, type FrameworkContext, type GraphQLJSON, type MethodHandlerType, type MethodSchemaType, ModuleConfigurations, ModuleHookContext, type Namespaces, type RequiredServiceType, type ResolvedMethodHandlerType, type ResolvedServiceType, type ServiceType, type Silgi, type SilgiAppPlugin, type SilgiConfig, type SilgiDefaultShared, SilgiEvent, type SilgiFunction, type SilgiHooks, type SilgiModuleContext, SilgiModuleOptions, type SilgiModuleShared, SilgiModules, SilgiOperation, type SilgiOptions, type SilgiServiceInterface, type SilgiStorageBase, type StorageConfig, type StorageKeyGenerator, type StorageKeyParams, type StorageMounts, autoImportTypes };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.4.12",
+  "version": "0.5.0",
   "sideEffects": false,
   "exports": {
     "./cli": {