inanis 0.0.7-beta.15 → 0.0.7-beta.18

package/dist/document-db/table-dynamo.js

@@ -256,10 +256,12 @@ export class DynamoDbTable {
             '#updatedAt': 'updatedAt'
         };
         for (let key in data) {
-            let [mode, value] = data[key];
-            ExpressionAttributeValues[`:${key}`] = value;
-            ExpressionAttributeNames[`#${key}`] = key;
-            UpdateExpressions.push(`#${key} = #${key} ${mode} :${key}`);
+            if (data[key] != null) {
+                let [mode, value] = data[key];
+                ExpressionAttributeValues[`:${key}`] = value;
+                ExpressionAttributeNames[`#${key}`] = key;
+                UpdateExpressions.push(`#${key} = #${key} ${mode} :${key}`);
+            }
         }
         await service.update({
             TableName: this.tableName,
@@ -279,7 +281,8 @@ export class DynamoDbTable {
             '#updatedAt': 'updatedAt'
         };
         for (let key in data) {
-            ExpressionAttributeValues[`:${key}`] = data[key];
+            const value = data[key] == null ? null : data[key];
+            ExpressionAttributeValues[`:${key}`] = value;
             ExpressionAttributeNames[`#${key}`] = key;
             UpdateExpressions.push(`#${key} = :${key}`);
         }
@@ -304,7 +307,8 @@ export class DynamoDbTable {
             '#updatedAt': 'updatedAt'
         };
         for (let key in data) {
-            ExpressionAttributeValues[`:${key}`] = data[key];
+            const value = data[key] == null ? null : data[key];
+            ExpressionAttributeValues[`:${key}`] = value;
             ExpressionAttributeNames[`#${key}`] = key;
             UpdateExpressions.push(`#${key} = :${key}`);
         }

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

@@ -58,6 +58,8 @@ export declare class DataModel<T extends DataModelConfig<any, any, any>, D exten
     data: D;
     constructor(config: T, data: T['_initData']);
     getPublic(): Pick<D, PublicKey>;
+    getCreateAt(): any;
+    getUpdateAt(): any;
     copy(): this;
     from(source: Partial<D> | DataModel<T, D, PublicKey>): void;
     save(reader?: (_data: D) => Partial<D>): Promise<void>;

package/dist/modules/data-model.js

@@ -96,6 +96,12 @@ export class DataModel {
         }
         return output;
     }
+    getCreateAt() {
+        return this.data.createdAt;
+    }
+    getUpdateAt() {
+        return this.data.updatedAt;
+    }
     copy() {
         const newData = structuredClone(this.data);
         const model = new DataModel(this._config, newData);

package/dist/stream/context.js

@@ -29,10 +29,10 @@ export class StreamRouterContext {
             name: `${this.method.action}@${this.method.router.path}`,
             interceptorMessage: (data) => data
         });
+        this.failMessages = this.method.failMessages;
         this.interaction.on('action', step => {
             this.interactionStepMessage = step.message;
         });
-        // 綁定協助解構
         const methods = Object.getOwnPropertyNames(StreamRouterContext.prototype);
         for (let key of methods) {
             if (key !== 'on' && key !== 'constructor' && typeof this[key] === 'function') {

package/dist/stream/index.js

@@ -5,15 +5,6 @@ import { rootException } from '../exception.js';
 import { exportOpenApi } from './export-open-api.js';
 import { Router } from './router.js';
 import { toRouterName } from '../utils/string.js';
-import { streamifyResponse, isInAWS } from 'lambda-stream';
-if (isInAWS() === false) {
-    global['awslambda'] = {
-        streamifyResponse,
-        HttpResponseStream: {
-            from: () => null
-        }
-    };
-}
 const exception = rootException.checkout('APIManager');
 const getLambdaGroup = (manager, method, path) => {
     let sourcePath = `${method}@${path}`;
@@ -96,7 +87,8 @@ export class StreamAPIManager extends Event {
         return null;
     }
     getMethod(path, method) {
-        let router = this.getRouter(path);
+        let targetPath = path.endsWith('-no-stream') ? path.slice(0, -10) : path;
+        let router = this.getRouter(targetPath);
         if (router == null) {
             return null;
         }
@@ -128,6 +120,7 @@ export class StreamAPIManager extends Event {
                 const outputs = {};
                 this.eachMethods((router, method) => {
                     const appendHandleName = 'Stream';
+                    const isOffline = !!this.params.serverless?.isOffline;
                     const group = getLambdaGroup(this, method, router.path);
                     const handlerName = group.handlerName + appendHandleName;
                     if (outputs[handlerName] == null) {
@@ -142,7 +135,6 @@ export class StreamAPIManager extends Event {
                             };
                             responseStream = awslambda.HttpResponseStream.from(responseStream, httpResponseMetadata);
                             let callPath = event.requestContext.resourcePath;
-                            let isOffline = !!this.params.serverless?.isOffline;
                             if (isOffline) {
                                 callPath = '/' + callPath.split('/').slice(2).join('/');
                             }
@@ -152,6 +144,50 @@ export class StreamAPIManager extends Event {
                             }
                             await method.outputs.lambdaHandler(event, responseStream);
                         });
+                        outputs[handlerName + 'NoStream'] = (event) => {
+                            return new Promise((resolve) => {
+                                let chunk = '';
+                                const headers = {
+                                    'Content-Type': 'text/plain; charset=UTF-8',
+                                    'Access-Control-Allow-Origin': '*',
+                                    'Access-Control-Allow-Credentials': 'true'
+                                };
+                                const streamEvent = new Event();
+                                const responseStream = {
+                                    on: streamEvent.on.bind(streamEvent),
+                                    end: () => {
+                                        streamEvent.emit('close', {});
+                                        resolve({
+                                            headers,
+                                            statusCode: 200,
+                                            body: chunk
+                                        });
+                                    },
+                                    write: (data) => {
+                                        chunk += data;
+                                    }
+                                };
+                                let callPath = event.requestContext.resourcePath;
+                                if (isOffline) {
+                                    callPath = '/' + callPath.split('/').slice(2).join('/');
+                                }
+                                let method = this.getMethod(callPath, event.httpMethod.toLocaleLowerCase());
+                                if (method == null) {
+                                    throw exception.create('No Stream Method Found');
+                                }
+                                method
+                                    .outputs
+                                    .lambdaHandler(event, responseStream)
+                                    .catch(err => {
+                                    console.error(err);
+                                    resolve({
+                                        headers,
+                                        statusCode: 400,
+                                        body: 'unknown error'
+                                    });
+                                });
+                            });
+                        };
                     }
                 });
                 return outputs;
@@ -169,17 +205,30 @@ export class StreamAPIManager extends Event {
                             memorySize: group.memorySize,
                             events: []
                         };
+                        outputs[group.name + 'NoStream'] = {
+                            handler: group.handler + 'NoStream',
+                            memorySize: group.memorySize,
+                            events: []
+                        };
                         if (params.handler) {
                             let newGroup = params.handler(outputs[group.name]);
                             if (newGroup) {
                                 outputs[group.name] = newGroup;
                             }
+                            let newNoStreamGroup = params.handler(outputs[group.name + 'NoStream']);
+                            if (newNoStreamGroup) {
+                                outputs[group.name + 'NoStream'] = newNoStreamGroup;
+                            }
                         }
                     }
                     const m = router.methods[method];
                     const output = outputs[group.name];
+                    const noStreamOutput = outputs[group.name + 'NoStream'];
                     output.events.push({
-                        http: m.outputs.getServerlessHttp()
+                        http: m.outputs.getServerlessHttp(true)
+                    });
+                    noStreamOutput.events.push({
+                        http: m.outputs.getServerlessHttp(false)
                     });
                 });
                 return toOutputData(outputs);

package/dist/stream/method.d.ts

@@ -52,7 +52,7 @@ export declare class Method<Path extends string = any, Fails extends FailData =
     run(context: StreamRouterContext): Promise<void>;
     get outputs(): {
         lambdaHandler: (event: APIGatewayEvent, responseStream: ResponseStream) => Promise<void>;
-        getServerlessHttp: () => Record<string, any>;
+        getServerlessHttp: (isStream: boolean) => Record<string, any>;
         openApiPathItem: () => {
             tags?: string[];
             summary?: string;

package/dist/stream/method.js

@@ -51,6 +51,7 @@ export class Method {
             await context.hook.notify('fail', {
                 error
             });
+            throw error;
         }
     }
     // =================
@@ -62,14 +63,9 @@ export class Method {
             lambdaHandler: async (event, responseStream) => {
                 await this.inanis._install();
                 const context = await StreamRouterContext.fromAwsLambda(this, event, responseStream);
-                try {
-                    await this.run(context);
-                }
-                catch (error) {
-                    console.log('response parse error:', error);
-                }
+                await this.run(context);
             },
-            getServerlessHttp: () => {
+            getServerlessHttp: (isStream) => {
                 const http = {
                     cors: {
                         origin: '*',
@@ -80,12 +76,14 @@ export class Method {
                             ...this.allowHeaders
                         ]
                     },
-                    path: this.router.path,
+                    path: isStream === false ? this.router.path + '-no-stream' : this.router.path,
                     method: this.action,
                     authorizer: undefined,
-                    response: {
-                        transferMode: 'STREAM'
-                    }
+                    response: isStream === false
+                        ? undefined
+                        : {
+                            transferMode: 'STREAM'
+                        }
                 };
                 if (this.router.nowAuthorizerExpression) {
                     http.authorizer = this.router.nowAuthorizerExpression.name;

package/package.json

@@ -1,13 +1,13 @@
 {
     "name": "inanis",
     "type": "module",
-    "version": "0.0.7-beta.15",
+    "version": "0.0.7-beta.18",
     "description": "Micro Service Best Tools.",
     "main": "./dist/index.js",
     "scripts": {
         "test": "nyc mocha ./lib/**/*.test.ts ./lib/*.test.ts",
         "build": "eslint 'src/**/*.{ts,tsx}' --fix && tsc",
-        "deploy": "ts-node ./deploy.ts"
+        "deploy": "esno ./deploy.ts"
     },
     "bin": {
         "ms-be-lib": "cli/index.js"
@@ -36,13 +36,13 @@
         "cross-env": "^10.0.0",
         "debug": "^4.4.1",
         "eslint": "^9.32.0",
+        "esno": "^4.8.0",
         "mocha": "^11.7.1",
         "nyc": "^17.1.0",
         "openapi-types": "^12.1.3",
         "semver": "^7.7.2",
         "supports-color": "^10.0.0",
         "ts-loader": "^9.5.2",
-        "ts-node": "^10.9.2",
         "typescript": "^5.8.3",
         "typescript-eslint": "^8.38.0"
     },
@@ -65,7 +65,6 @@
         "json-schema-to-typescript": "^15.0.4",
         "json-to-pretty-yaml": "^1.2.2",
         "jsonwebtoken": "^9.0.2",
-        "lambda-stream": "^0.6.0",
         "mime": "^4.1.0",
         "mongodb": "^7.0.0",
         "node-rsa": "^1.1.1",
@@ -78,4 +77,4 @@
         "zod": "^4.2.1"
     },
     "packageManager": "yarn@4.1.1"
-}
+}