serverless-simple-middleware 0.0.62 → 0.0.65

package/dist/middleware/trace.js

@@ -1,66 +1,26 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TracerPlugin = exports.TracerWrapper = exports.Tracer = exports.TracerLog = void 0;
-var uuid_1 = require("uuid");
-var aws_1 = require("../aws");
-var utils_1 = require("../utils");
-var ts_enum_util_1 = require("ts-enum-util");
-var base_1 = require("./base");
-var client_sqs_1 = require("@aws-sdk/client-sqs");
-var logger = (0, utils_1.getLogger)(__filename);
-var TracerLog = /** @class */ (function () {
-    function TracerLog(route, key, system, action, attribute, body, error, client, version) {
+const uuid_1 = require("uuid");
+const aws_1 = require("../aws");
+const utils_1 = require("../utils");
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+const ts_enum_util_1 = require("ts-enum-util");
+const base_1 = require("./base");
+const logger = (0, utils_1.getLogger)(__filename);
+class TracerLog {
+    route;
+    key;
+    system;
+    action;
+    attribute;
+    body;
+    error;
+    client;
+    version;
+    uuid;
+    timestamp;
+    constructor(route, key, system, action, attribute, body, error, client, version) {
         this.route = route;
         this.key = key;
         this.system = system;
@@ -73,76 +33,61 @@ var TracerLog = /** @class */ (function () {
         this.uuid = (0, uuid_1.v4)();
         this.timestamp = Date.now();
     }
-    return TracerLog;
-}());
+}
 exports.TracerLog = TracerLog;
-var Tracer = /** @class */ (function () {
-    function Tracer(queueName, sqs) {
-        var _this = this;
-        this.push = function (log) { return _this.buffer.push(log); };
-        this.flush = function () { return __awaiter(_this, void 0, void 0, function () {
-            var urlResult, eventQueueUrl, chunkSize, begin, end, subset, sendBatchResult, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.buffer.length === 0) {
-                            return [2 /*return*/];
-                        }
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 7, , 8]);
-                        return [4 /*yield*/, this.sqs.getQueueUrl({
-                                QueueName: this.queueName,
-                            })];
-                    case 2:
-                        urlResult = _a.sent();
-                        logger.stupid("urlResult", urlResult);
-                        if (!urlResult.QueueUrl) {
-                            throw new Error("No queue url with name[".concat(this.queueName, "]"));
-                        }
-                        eventQueueUrl = urlResult.QueueUrl;
-                        chunkSize = 10;
-                        begin = 0;
-                        _a.label = 3;
-                    case 3:
-                        if (!(begin < this.buffer.length)) return [3 /*break*/, 6];
-                        end = Math.min(this.buffer.length, begin + chunkSize);
-                        subset = this.buffer.slice(begin, end);
-                        return [4 /*yield*/, this.sqs.sendMessageBatch({
-                                QueueUrl: eventQueueUrl,
-                                Entries: subset.map(function (each) { return ({
-                                    Id: "".concat(each.key, "_").concat(each.uuid),
-                                    MessageBody: JSON.stringify(each),
-                                }); }),
-                            })];
-                    case 4:
-                        sendBatchResult = _a.sent();
-                        logger.stupid("sendBatchResult", sendBatchResult);
-                        _a.label = 5;
-                    case 5:
-                        begin += chunkSize;
-                        return [3 /*break*/, 3];
-                    case 6:
-                        this.buffer = [];
-                        return [3 /*break*/, 8];
-                    case 7:
-                        error_1 = _a.sent();
-                        logger.warn("Error in eventSource: ".concat(error_1));
-                        return [3 /*break*/, 8];
-                    case 8: return [2 /*return*/];
-                }
-            });
-        }); };
+class Tracer {
+    queueName;
+    sqs;
+    buffer;
+    constructor(queueName, sqs) {
         this.queueName = queueName;
         this.sqs = sqs;
         this.buffer = [];
     }
-    return Tracer;
-}());
+    push = (log) => this.buffer.push(log);
+    flush = async () => {
+        if (this.buffer.length === 0) {
+            return;
+        }
+        try {
+            const urlResult = await this.sqs.getQueueUrl({
+                QueueName: this.queueName,
+            });
+            logger.stupid(`urlResult`, urlResult);
+            if (!urlResult.QueueUrl) {
+                throw new Error(`No queue url with name[${this.queueName}]`);
+            }
+            const eventQueueUrl = urlResult.QueueUrl;
+            const chunkSize = 10;
+            for (let begin = 0; begin < this.buffer.length; begin += chunkSize) {
+                const end = Math.min(this.buffer.length, begin + chunkSize);
+                const subset = this.buffer.slice(begin, end);
+                const sendBatchResult = await this.sqs.sendMessageBatch({
+                    QueueUrl: eventQueueUrl,
+                    Entries: subset.map((each) => ({
+                        Id: `${each.key}_${each.uuid}`,
+                        MessageBody: JSON.stringify(each),
+                    })),
+                });
+                logger.stupid(`sendBatchResult`, sendBatchResult);
+            }
+            this.buffer = [];
+        }
+        catch (error) {
+            logger.warn(`Error in eventSource: ${error}`);
+        }
+    };
+}
 exports.Tracer = Tracer;
-var TracerWrapper = /** @class */ (function () {
-    function TracerWrapper(tracer, route, system, key, action, client, version) {
-        var _this = this;
+class TracerWrapper {
+    tracer;
+    route;
+    system;
+    key;
+    action;
+    client;
+    version;
+    constructor(tracer, route, system, key, action, client, version) {
         this.tracer = tracer;
         this.route = route;
         this.system = system;
@@ -150,106 +95,89 @@ var TracerWrapper = /** @class */ (function () {
         this.action = action;
         this.client = client;
         this.version = version;
-        this.push = function (attribute, body, error) {
-            if (error === void 0) { error = false; }
-            _this.tracer.push(new TracerLog(_this.route, _this.key, _this.system, _this.action, attribute, body, error, _this.client, _this.version));
-        };
-        this.send = function (log) {
-            _this.tracer.push(new TracerLog(log.route || _this.route, log.key || _this.key, log.system || _this.system, log.action || _this.action, log.attribute, log.body, log.error || false, log.client || _this.client, log.version || _this.version));
-        };
     }
-    return TracerWrapper;
-}());
+    push = (attribute, body, error = false) => {
+        this.tracer.push(new TracerLog(this.route, this.key, this.system, this.action, attribute, body, error, this.client, this.version));
+    };
+    send = (log) => {
+        this.tracer.push(new TracerLog(log.route || this.route, log.key || this.key, log.system || this.system, log.action || this.action, log.attribute, log.body, log.error || false, log.client || this.client, log.version || this.version));
+    };
+}
 exports.TracerWrapper = TracerWrapper;
-var TracerPlugin = /** @class */ (function (_super) {
-    __extends(TracerPlugin, _super);
-    function TracerPlugin(options) {
-        var _this = _super.call(this) || this;
-        _this.create = function () { return __awaiter(_this, void 0, void 0, function () {
-            var awsConfig, _a, sqs, tracer;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!this.options.awsConfig) return [3 /*break*/, 2];
-                        return [4 /*yield*/, (0, aws_1.loadAWSConfig)(this.options.awsConfig)];
-                    case 1:
-                        _a = _b.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        _a = undefined;
-                        _b.label = 3;
-                    case 3:
-                        awsConfig = _a;
-                        sqs = (function () {
-                            if (!awsConfig) {
-                                return new client_sqs_1.SQS({
-                                    region: _this.options.region,
-                                });
-                            }
-                            (0, ts_enum_util_1.$enum)(aws_1.AWSComponent).forEach(function (eachComponent) {
-                                var config = awsConfig.get(eachComponent);
-                                if (config) {
-                                    config.region = _this.options.region;
-                                }
-                            });
-                            return new aws_1.SimpleAWS(awsConfig).sqs;
-                        })();
-                        this.tracer = new Tracer(this.options.queueName, sqs);
-                        tracer = function (key, action) {
-                            _this.last = { key: key, action: action };
-                            return new TracerWrapper(_this.tracer, _this.options.route, _this.options.system, key, action, _this.client.agent, _this.client.version);
-                        };
-                        return [2 /*return*/, { tracer: tracer }];
-                }
-            });
-        }); };
-        _this.begin = function (_a) {
-            var request = _a.request;
-            _this.client.version = request.header('X-Version') || '0.0.0';
-            _this.client.agent = (function () {
-                var fromHeader = request.header('User-Agent');
-                if (fromHeader) {
-                    return fromHeader;
-                }
-                if (request.context &&
-                    request.context.identity &&
-                    request.context.identity.userAgent) {
-                    return request.context.identity.userAgent;
-                }
-                return '';
-            })();
-        };
-        _this.end = function () { return _this.tracer.flush(); };
-        _this.error = function (_a) {
-            var request = _a.request, aux = _a.aux;
-            if (!aux) {
-                console.warn('Aux is not initialized');
-                return;
-            }
-            if (!request.lastError) {
-                return;
-            }
-            var _b = _this.last, key = _b.key, action = _b.action;
-            aux
-                .tracer(key, action)
-                .push('error', typeof request.lastError === 'string'
-                ? request.lastError
-                : (0, utils_1.stringifyError)(request.lastError), true);
-        };
-        _this.options = options;
-        _this.last = {
+class TracerPlugin extends base_1.HandlerPluginBase {
+    tracer;
+    options;
+    last;
+    client;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.last = {
             key: 'nothing',
             action: 'unknown',
         };
-        _this.client = {
+        this.client = {
             agent: '',
             version: '',
         };
-        return _this;
     }
-    return TracerPlugin;
-}(base_1.HandlerPluginBase));
+    create = async () => {
+        const awsConfig = this.options.awsConfig
+            ? await (0, aws_1.loadAWSConfig)(this.options.awsConfig)
+            : undefined;
+        const sqs = (() => {
+            if (!awsConfig) {
+                return new client_sqs_1.SQS({
+                    region: this.options.region,
+                });
+            }
+            (0, ts_enum_util_1.$enum)(aws_1.AWSComponent).forEach((eachComponent) => {
+                const config = awsConfig.get(eachComponent);
+                if (config) {
+                    config.region = this.options.region;
+                }
+            });
+            return new aws_1.SimpleAWS(awsConfig).sqs;
+        })();
+        this.tracer = new Tracer(this.options.queueName, sqs);
+        const tracer = (key, action) => {
+            this.last = { key, action };
+            return new TracerWrapper(this.tracer, this.options.route, this.options.system, key, action, this.client.agent, this.client.version);
+        };
+        return { tracer };
+    };
+    begin = ({ request }) => {
+        this.client.version = request.header('X-Version') || '0.0.0';
+        this.client.agent = (() => {
+            const fromHeader = request.header('User-Agent');
+            if (fromHeader) {
+                return fromHeader;
+            }
+            if (request.context &&
+                request.context.identity &&
+                request.context.identity.userAgent) {
+                return request.context.identity.userAgent;
+            }
+            return '';
+        })();
+    };
+    end = () => this.tracer.flush();
+    error = ({ request, aux }) => {
+        if (!aux) {
+            console.warn('Aux is not initialized');
+            return;
+        }
+        if (!request.lastError) {
+            return;
+        }
+        const { key, action } = this.last;
+        aux
+            .tracer(key, action)
+            .push('error', typeof request.lastError === 'string'
+            ? request.lastError
+            : (0, utils_1.stringifyError)(request.lastError), true);
+    };
+}
 exports.TracerPlugin = TracerPlugin;
-var build = function (options) { return new TracerPlugin(options); };
+const build = (options) => new TracerPlugin(options);
 exports.default = build;

package/dist/utils/logger.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLogger = exports.Logger = exports.currentLogLevel = exports.LogLevel = void 0;
-var path_1 = require("path");
-var simple_staging_1 = require("simple-staging");
-var ts_enum_util_1 = require("ts-enum-util");
-var misc_1 = require("./misc");
+const path_1 = require("path");
+const simple_staging_1 = require("simple-staging");
+const ts_enum_util_1 = require("ts-enum-util");
+const misc_1 = require("./misc");
 var LogLevel;
 (function (LogLevel) {
     LogLevel["Error"] = "error";
@@ -15,7 +15,7 @@ var LogLevel;
     LogLevel["Silly"] = "silly";
     LogLevel["Stupid"] = "stupid";
 })(LogLevel || (exports.LogLevel = LogLevel = {}));
-var severity = function (level) {
+const severity = (level) => {
     switch (level) {
         case LogLevel.Error:
             return 100;
@@ -38,35 +38,34 @@ var severity = function (level) {
 exports.currentLogLevel = (0, ts_enum_util_1.$enum)(LogLevel).asValueOrDefault(process.env.LOG_LEVEL, simple_staging_1.envDefault.level !== simple_staging_1.StagingLevel.Release
     ? LogLevel.Verbose
     : LogLevel.Debug);
-var Logger = /** @class */ (function () {
-    function Logger(name, level) {
-        if (level === void 0) { level = exports.currentLogLevel; }
-        var _this = this;
-        this.log = function (level, message) {
-            if (_this.severity >= severity(level)) {
-                console.log("[".concat(new Date().toISOString(), "][").concat(level.toUpperCase(), "][").concat(_this.name, "] ").concat(message instanceof Error ? (0, misc_1.stringifyError)(message) : message));
-            }
-            return message;
-        };
-        this.error = function (message) { return _this.log(LogLevel.Error, message); };
-        this.warn = function (message) { return _this.log(LogLevel.Warn, message); };
-        this.info = function (message) { return _this.log(LogLevel.Info, message); };
-        this.debug = function (message) { return _this.log(LogLevel.Debug, message); };
-        this.verbose = function (message) { return _this.log(LogLevel.Verbose, message); };
-        this.silly = function (message) { return _this.log(LogLevel.Silly, message); };
-        this.stupid = function (message, object, replacer) {
-            _this.log(LogLevel.Stupid, "".concat(message, ": ").concat(JSON.stringify(object, replacer)));
-            return object;
-        };
+class Logger {
+    name;
+    severity;
+    constructor(name, level = exports.currentLogLevel) {
         this.name = name;
         this.severity = severity(level);
     }
-    return Logger;
-}());
+    log = (level, message) => {
+        if (this.severity >= severity(level)) {
+            console.log(`[${new Date().toISOString()}][${level.toUpperCase()}][${this.name}] ${message instanceof Error ? (0, misc_1.stringifyError)(message) : message}`);
+        }
+        return message;
+    };
+    error = (message) => this.log(LogLevel.Error, message);
+    warn = (message) => this.log(LogLevel.Warn, message);
+    info = (message) => this.log(LogLevel.Info, message);
+    debug = (message) => this.log(LogLevel.Debug, message);
+    verbose = (message) => this.log(LogLevel.Verbose, message);
+    silly = (message) => this.log(LogLevel.Silly, message);
+    stupid = (message, object, replacer) => {
+        this.log(LogLevel.Stupid, `${message}: ${JSON.stringify(object, replacer)}`);
+        return object;
+    };
+}
 exports.Logger = Logger;
-var loggers = {};
-var getLogger = function (fileName, level) {
-    var name = (0, path_1.basename)(fileName);
+const loggers = {};
+const getLogger = (fileName, level) => {
+    const name = (0, path_1.basename)(fileName);
     if (loggers[name] === undefined) {
         loggers[name] = new Logger(name, level);
     }

package/dist/utils/misc.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stringifyError = void 0;
-var AwsError_1 = require("../internal/AwsError");
-var stringifyError = function (err, replacer, space) {
-    var error = isAWSv3Error(err) ? new AwsError_1.AwsError(err) : err;
-    var plainObject = {};
-    Object.getOwnPropertyNames(error).forEach(function (key) {
+const AwsError_1 = require("../internal/AwsError");
+const stringifyError = (err, replacer, space) => {
+    const error = isAWSv3Error(err) ? new AwsError_1.AwsError(err) : err;
+    const plainObject = {};
+    Object.getOwnPropertyNames(error).forEach((key) => {
         plainObject[key] = error[key];
     });
     return JSON.stringify(plainObject, replacer, space);
 };
 exports.stringifyError = stringifyError;
-var isAWSv3Error = function (error) {
+const isAWSv3Error = (error) => {
     return error instanceof Error && 'name' in error && '$metadata' in error;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "serverless-simple-middleware",
   "description": "Simple middleware to translate the interface of lambda's handler to request => response",
-  "version": "0.0.62",
+  "version": "0.0.65",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "VoyagerX",
@@ -22,12 +22,12 @@
   "homepage": "https://github.com/v6x/serverless-simple-middleware#readme",
   "scripts": {
     "lint": "tslint --project tsconfig.json",
+    "clean": "rm -rf dist && rm -rf node_modules && yarn install",
     "build": "tsc --project tsconfig.json",
     "build:watch": "tsc --project tsconfig.json --watch",
     "test": "jest --config jest.config.js",
     "test:watch": "jest --config jest.config.js --watch",
-    "deploy": "yarn build && yarn publish",
-    "clean": "rm -rf dist && rm -rf node_modules && yarn install"
+    "deploy": "yarn build && yarn publish"
   },
   "dependencies": {
     "@aws-sdk/client-dynamodb": "^3.828.0",
@@ -40,7 +40,9 @@
     "@types/aws-lambda": "8",
     "@types/mysql": "^2.15.5",
     "cross-fetch": "^2.2.2",
+    "kysely": "^0.28.2",
     "mysql": "^2.16.0",
+    "mysql2": "^3.14.1",
     "nanoid": "4.0.2",
     "p-limit": "^2.0.0",
     "simple-staging": "^0.0.12",

package/src/aws/index.ts

@@ -1,3 +1,3 @@
-export * from './define';
 export * from './config';
+export * from './define';
 export * from './simple';

package/src/aws/simple.ts

@@ -6,13 +6,12 @@ import {
 import { envDefault as currentStage } from 'simple-staging';
 
 import * as fs from 'fs';
-import * as os from 'os';
 import { nanoid } from 'nanoid/non-secure';
+import * as os from 'os';
 
 import { getLogger, stringifyError } from '../utils';
 import { SimpleAWSConfig } from './config';
 
-import { AWSComponent, SQSMessageBody } from './define';
 import { DynamoDB, DynamoDBClient } from '@aws-sdk/client-dynamodb';
 import {
   AbortMultipartUploadCommand,
@@ -32,9 +31,10 @@ import {
 } from '@aws-sdk/client-s3';
 import { SQS } from '@aws-sdk/client-sqs';
 import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
+import { Upload } from '@aws-sdk/lib-storage';
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { PresignerOptions } from '../internal/s3';
-import { Upload } from '@aws-sdk/lib-storage';
+import { AWSComponent, SQSMessageBody } from './define';
 
 const logger = getLogger(__filename);
 

package/src/middleware/base.ts

@@ -1,4 +1,7 @@
-import * as awsTypes from 'aws-lambda'; // tslint:disable-line:no-implicit-dependencies
+import type {
+  APIGatewayEvent,
+  APIGatewayEventRequestContext,
+} from 'aws-lambda';
 import { getLogger } from '../utils/logger';
 
 const logger = getLogger(__filename);
@@ -8,8 +11,8 @@ export interface RequestAuxBase {
 }
 
 export class HandlerRequest {
-  public event: awsTypes.APIGatewayEvent;
-  public context: awsTypes.APIGatewayEventRequestContext;
+  public event: APIGatewayEvent;
+  public context: APIGatewayEventRequestContext;
   public lastError: Error | string | undefined;
 
   private lazyBody?: any;
@@ -110,15 +113,29 @@ export class HandlerResponse {
     key: string,
     value: string,
     domain?: string,
-    specifyCrossOrigin?: true,
+    sameSite?: 'None' | 'Lax' | 'Strict',
+    secure?: boolean,
     path?: string,
+    httpOnly?: boolean,
+    maxAgeSeconds?: number,
   ) {
     const keyValueStr = `${key}=${value}`;
     const domainStr = domain ? `Domain=${domain}` : '';
-    const sameSiteStr = specifyCrossOrigin ? 'SameSite=None' : '';
-    const secureStr = specifyCrossOrigin ? 'Secure' : '';
+    const sameSiteStr = sameSite ? `SameSite=${sameSite}` : '';
+    const secureStr = secure ? 'Secure' : '';
     const pathStr = path !== undefined ? `Path=${path}` : '';
-    const cookieStr = [keyValueStr, domainStr, sameSiteStr, secureStr, pathStr]
+    const httpOnlyStr = httpOnly ? 'HttpOnly' : '';
+    const maxAgeStr =
+      maxAgeSeconds || maxAgeSeconds === 0 ? `Max-Age=${maxAgeSeconds}` : '';
+    const cookieStr = [
+      keyValueStr,
+      domainStr,
+      sameSiteStr,
+      secureStr,
+      pathStr,
+      httpOnlyStr,
+      maxAgeStr,
+    ]
       .filter((x) => x)
       .join('; ');
     this.cookies.push(cookieStr);