inanis 0.0.7-beta.4 → 0.0.7-beta.6

package/dist/api/index.d.ts

@@ -32,7 +32,6 @@ export declare class APIManager extends Event<Channels> {
     routers: Router[];
     constructor(params: Params);
     _injectInanis(inanis: Inanis): void;
-    loadAll(routers?: Router<any, any, string, Record<string, any>, Record<string, any>>[]): Promise<void>;
     createRoute<Path extends string, Fails extends FailData, BeforeData, Headers extends string>(params: RouterParams<Path, Fails, Record<any, any>, BeforeData, Headers>): Router<Path, Fails, Headers, Record<any, any>, BeforeData>;
     eachMethods(cb: (_route: Router, _method: keyof Methods) => void): void;
     getRouter(path: string): Router<any, any, string, Record<string, any>, Record<string, any>>;
@@ -43,13 +42,15 @@ export declare class APIManager extends Event<Channels> {
             json: string;
             yaml: string;
         }>>;
-        expressHandlers: () => Promise<{
+        expressHandlers: () => {
             path: string;
             method: string;
             handler: (..._args: any[]) => void;
-        }[]>;
-        lambdaHandler: () => Promise<Record<string, APIGatewayProxyHandler>>;
-        serverlessFunctionsConfig: () => Promise<{
+        }[];
+        lambdaHandler: () => Record<string, APIGatewayProxyHandler>;
+        serverlessFunctionsConfig: (params?: {
+            handler: (group: any) => any;
+        }) => Promise<{
             json: string;
             yaml: string;
         }>;

package/dist/api/index.js

@@ -54,19 +54,6 @@ class APIManager extends power_helper_1.Event {
             inanis
         });
     }
-    async loadAll(routers = this.routers) {
-        let loadedFlag = false;
-        while (!loadedFlag) {
-            loadedFlag = true;
-            for (let router of routers) {
-                if (!router.loaded) {
-                    await router.load();
-                    await this.loadAll(router.children);
-                    loadedFlag = false;
-                }
-            }
-        }
-    }
     createRoute(params) {
         const route = new router_js_1.Router(this, params);
         this.routers.push(route);
@@ -122,7 +109,6 @@ class APIManager extends power_helper_1.Event {
     get outputs() {
         return {
             toTypes: async () => {
-                await this.loadAll();
                 const outputs = [];
                 const openApi = await this.outputs.openApiDocument({ servers: [] });
                 for (let doc in openApi) {
@@ -131,15 +117,13 @@ class APIManager extends power_helper_1.Event {
                 return outputs.join('\n\n');
             },
             openApiDocument: async (params) => {
-                await this.loadAll();
                 const outputs = {};
                 for (let router of this.routers) {
                     outputs[router.name] = await (0, export_open_api_js_1.exportOpenApi)(router, params);
                 }
                 return outputs;
             },
-            expressHandlers: async () => {
-                await this.loadAll();
+            expressHandlers: () => {
                 const output = [];
                 this.eachMethods((route, method) => {
                     let path = route.path.replace('{', ':').replace('}', '');
@@ -153,8 +137,8 @@ class APIManager extends power_helper_1.Event {
                 });
                 return output;
             },
-            lambdaHandler: async () => {
-                await this.loadAll();
+            // 不支援非同步
+            lambdaHandler: () => {
                 const outputs = {};
                 this.eachMethods((router, method) => {
                     const group = getLambdaGroup(this, method, router.path);
@@ -176,8 +160,7 @@ class APIManager extends power_helper_1.Event {
                 });
                 return outputs;
             },
-            serverlessFunctionsConfig: async () => {
-                await this.loadAll();
+            serverlessFunctionsConfig: async (params) => {
                 const outputs = {};
                 this.eachMethods((router, method) => {
                     let group = getLambdaGroup(this, method, router.path);
@@ -190,6 +173,12 @@ class APIManager extends power_helper_1.Event {
                             memorySize: group.memorySize,
                             events: []
                         };
+                        if (params.handler) {
+                            let newGroup = params.handler(outputs[group.name]);
+                            if (newGroup) {
+                                outputs[group.name] = newGroup;
+                            }
+                        }
                     }
                     const m = router.methods[method];
                     const output = outputs[group.name];

package/dist/api/router.d.ts

@@ -24,8 +24,6 @@ export type RouterParams<Path extends string, Fails extends FailData, ParentData
 };
 export declare class Router<Path extends string = any, Fails extends FailData = any, Headers extends string = string, ParentData = Record<string, any>, BeforeData = Record<string, any>> {
     tags: string[];
-    loaded: boolean;
-    loadCallback: (() => Promise<void>) | null;
     path: Path;
     manager: APIManager;
     before: (_data: any, _context: any) => Promise<BeforeData>;
@@ -41,8 +39,6 @@ export declare class Router<Path extends string = any, Fails extends FailData =
     get schema(): typeof definedValidateSchema;
     get nowAuthorizerExpression(): AuthorizerExpression | null;
     child<ChildPath extends `${Path}/${string}`, ChildBeforeData, ChildFails extends FailData, ChildHeaders extends string>(params: RouterParams<ChildPath, ChildFails, BeforeData, ChildBeforeData, ChildHeaders>): Router<ChildPath, ChildFails, ChildHeaders, BeforeData, ChildBeforeData>;
-    onLoad(cb: (() => Promise<void>)): void;
-    load(): Promise<void>;
     export(): Record<string, Router<any, any, string, Record<string, any>, Record<string, any>>>;
     deepEachChildren(callback: (_route: Router) => void | '_break'): any;
     getParents(): Router<any, any, string, Record<string, any>, Record<string, any>>[];

package/dist/api/router.js

@@ -7,8 +7,6 @@ const validate_js_1 = require("../utils/validate.js");
 const string_js_1 = require("../utils/string.js");
 class Router {
     tags;
-    loaded = false;
-    loadCallback = null;
     path;
     manager;
     before;
@@ -56,15 +54,6 @@ class Router {
         router.parent = this;
         return router;
     }
-    onLoad(cb) {
-        this.loadCallback = cb;
-    }
-    async load() {
-        this.loaded = true;
-        if (this.loadCallback) {
-            await this.loadCallback();
-        }
-    }
     export() {
         const output = {};
         const parse = (route) => {

package/dist/main.d.ts

@@ -21,6 +21,8 @@ export declare class Inanis {
     private getProcessManagers;
     eachManagements(cb: (_manager: Manager) => Promise<any>): Promise<void>;
     toLambdaHandlers(): {};
-    toServerlessFunctions: () => Promise<string>;
+    toServerlessFunctions: (params?: {
+        handler: (group: any) => any;
+    }) => Promise<string>;
 }
 export {};

package/dist/main.js

@@ -55,11 +55,11 @@ class Inanis {
         });
         return outputs;
     }
-    toServerlessFunctions = async () => {
+    toServerlessFunctions = async (params) => {
         const output = [];
         await this.eachManagements(async (manager) => {
             if ('outputs' in manager && 'serverlessFunctionsConfig' in manager.outputs) {
-                let { yaml } = await manager.outputs.serverlessFunctionsConfig();
+                let { yaml } = await manager.outputs.serverlessFunctionsConfig(params);
                 output.push(yaml);
             }
         });

package/dist/modules/data-model.d.ts

@@ -3,6 +3,7 @@ export declare class DataModelConfig<T extends TableManager<any, any, any, any,
     table: T;
     defData: DefData;
     publicKeys: PublicKey[];
+    publicKeyMaps: Record<PublicKey, true>;
     _initData: Omit<T['_putType'], keyof ReturnType<DefData>> & Partial<T['_putType']>;
     constructor(params: {
         table: T;

package/dist/modules/data-model.js

@@ -6,11 +6,13 @@ class DataModelConfig {
     table;
     defData;
     publicKeys;
+    publicKeyMaps = {};
     _initData = null;
     constructor(params) {
         this.table = params.table;
         this.defData = params.defData;
         this.publicKeys = params.publicKeys;
+        this.publicKeyMaps = Object.fromEntries(this.publicKeys.map(k => [k, true]));
     }
     newData(data) {
         return {

package/dist/utils/validate.d.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod';
 import { DeepRequired } from '../types.js';
-import type { ZodAny } from 'zod';
-export type ValidateCallback<T extends Record<string, ZodAny>> = (_z: typeof z) => {
+import type { ZodType } from 'zod';
+export type ValidateCallback<T extends Record<string, ZodType>> = (_z: typeof z) => {
     [K in keyof T]: T[K];
 };
 export type ValidateCallbackOutputs<T extends ValidateCallback<any>, R = ReturnType<T>> = {
-    [K in keyof R]: R[K] extends ZodAny ? DeepRequired<z.infer<R[K]>> : unknown;
+    [K in keyof R]: R[K] extends ZodType ? DeepRequired<z.infer<R[K]>> : unknown;
 };
 export declare function definedValidateSchema<T extends ValidateCallback<any>>(cb: T): T;
-export declare function validate<T extends ValidateCallback<any>, R = ReturnType<T>>(target: any, schemaCallback: T): { [K in keyof R]: R[K] extends ZodAny ? DeepRequired<z.infer<R[K]>> : unknown; };
+export declare function validate<T extends ValidateCallback<any>, R = ReturnType<T>>(target: any, schemaCallback: T): { [K in keyof R]: R[K] extends ZodType ? DeepRequired<z.infer<R[K]>> : unknown; };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "inanis",
-    "version": "0.0.7-beta.4",
+    "version": "0.0.7-beta.6",
     "description": "Micro Service Best Tools.",
     "main": "./dist/index.js",
     "scripts": {