@jd-data-limited/easy-fm 4.0.4 → 4.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jd-data-limited/easy-fm",
-  "version": "4.0.4",
+  "version": "4.0.5",
   "dependencies": {
     "follow-redirects": "^1.15.5",
     "moment": "^2.29.4"
@@ -36,7 +36,9 @@
     "@types/btoa": "^1.2.3",
     "@types/events": "^3.0.0",
     "@types/follow-redirects": "^1.14.4",
+    "@types/inquirer": "^9.0.7",
     "dotenv": "^16.3.1",
+    "inquirer": "^9.2.13",
     "ts-morph": "^21.0.1",
     "typescript": "^5.3.3",
     "webpack": "^5.81.0",
@@ -44,5 +46,8 @@
   },
   "engines": {
     "node": ">=20.9.0"
+  },
+  "bin": {
+    "easyfm": "src/bin/cli.js"
   }
 }

package/src/FMError.d.ts

@@ -6,7 +6,6 @@ export declare class FMError extends Error {
     readonly httpStatus: number;
     readonly res: any;
     readonly code: number;
-    readonly message: string;
     readonly messages: string;
     constructor(code: string | number, httpStatus: number, res: any, trace?: Error);
 }

package/src/FMError.js

@@ -1016,7 +1016,6 @@ export class FMError extends Error {
     httpStatus;
     res;
     code;
-    message;
     messages;
     constructor(code, httpStatus, res, trace) {
         if (typeof code === "string")

package/src/FMError.ts

@@ -1018,7 +1018,6 @@ export class FMError extends Error {
     readonly httpStatus: number
     readonly res: any
     readonly code: number
-    readonly message: string
     readonly messages: string
 
     constructor(code: string | number, httpStatus: number, res: any, trace?: Error) {

package/src/bin/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/src/bin/cli.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+"use strict";
+/*
+ * Copyright (c) 2024. See LICENSE file for more information
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var commander_1 = require("commander");
+var generateTypes_js_1 = require("./generateTypes.js");
+var program = new commander_1.Command();
+program
+    .name("easyfm")
+    .description("A NodeJS wrapper for the FileMaker Data CLI");
+program
+    .command("generate-types")
+    .description("Automatically generate layout interfaces from your database")
+    .action(function () {
+    (0, generateTypes_js_1.generateTypesCLI)();
+});
+program.parse(process.argv);

package/src/bin/cli.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+/*
+ * Copyright (c) 2024. See LICENSE file for more information
+ */
+
+import {Command} from "commander"
+import {generateTypesCLI} from "./generateTypes.js";
+
+const program = new Command()
+
+program
+    .name("easyfm")
+    .description("A NodeJS wrapper for the FileMaker Data CLI")
+
+program
+    .command("generate-types")
+    .description("Automatically generate layout interfaces from your database")
+    .action(() => {
+        generateTypesCLI()
+    })
+
+program.parse(process.argv)

package/src/bin/generateTypes.d.ts

@@ -0,0 +1 @@
+export declare function generateTypesCLI(): Promise<void>;

package/src/bin/generateTypes.js

@@ -0,0 +1,250 @@
+"use strict";
+/*
+ * Copyright (c) 2024. See LICENSE file for more information
+ */
+var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+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.generateTypesCLI = void 0;
+var apiResults_js_1 = require("../models/apiResults.js");
+var inquirer_1 = require("inquirer");
+var FMHost_js_1 = require("../connection/FMHost.js");
+var fs = require("fs");
+function sub(str) {
+    return str
+        .replace(/[^a-zA-Z0-9_]/g, "") // Remove non-alphanumeric characters
+        .replace(/^[0-9]+/g, ''); // Removing leading numbers
+}
+function generateFieldType(field) {
+    switch (field.result) {
+        case apiResults_js_1.ApiFieldResultTypes.TEXT:
+            return "FieldBase<string>";
+        case apiResults_js_1.ApiFieldResultTypes.CONTAINER:
+            return "FieldBase<Container>";
+        case apiResults_js_1.ApiFieldResultTypes.DATE:
+            return "FieldBase<Date>";
+        case apiResults_js_1.ApiFieldResultTypes.NUMBER:
+            return "FieldBase<number>";
+        case apiResults_js_1.ApiFieldResultTypes.TIME:
+            return "FieldBase<Date>";
+        case apiResults_js_1.ApiFieldResultTypes.TIMESTAMP:
+            return "FieldBase<Date>";
+    }
+}
+function processFieldsChunk(fields) {
+    var existing_fields = [];
+    fields = fields.filter(function (field) {
+        if (existing_fields.includes(field.name))
+            return false;
+        existing_fields.push(field.name);
+        return true;
+    });
+    return fields.map(function (field) {
+        return JSON.stringify(field.name) + ": " + generateFieldType(field);
+    });
+}
+function camelToSnakeCase(str) {
+    return str.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
+}
+function safeStringInjection(str) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    var result = "";
+    for (var i = 0; i < str.length; i++) {
+        result += str[i];
+        if (i < args.length) {
+            result += JSON.stringify(args[i].toString());
+        }
+    }
+    return result;
+}
+function generateTypesCLI() {
+    return __awaiter(this, void 0, void 0, function () {
+        var data, HOST, DATABASE, stream, layouts, layoutInterfaces, _loop_1, _i, layouts_1, layout, layoutInterfaceLinks, _a, layoutInterfaces_1, layout, _b, layoutInterfaces_2, layout;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    process.stdout.write('\x1Bc');
+                    console.log("For this tool to work, you are required to have access to an account on the target database.\n" +
+                        "This account must have the fmrest extended privilege enabled.\n" +
+                        "This tool can only export type interfaces for layouts that the given account has access to.");
+                    console.log("\n");
+                    return [4 /*yield*/, inquirer_1.default.prompt([
+                            {
+                                type: "input",
+                                name: "hostname",
+                                message: "The IP address/domain of your FileMaker server (must start with either http:// or https://)",
+                                validate: function (input) {
+                                    return input.startsWith("http://") || input.startsWith("https://") || "Please enter a valid IP address/domain starting with http:// or https://";
+                                }
+                            },
+                            {
+                                type: "number",
+                                name: "timezoneOffset",
+                                message: "Server timezone offset (minutes)",
+                                default: 0 - (new Date()).getTimezoneOffset()
+                            },
+                            {
+                                type: "confirm",
+                                name: "verify",
+                                default: true,
+                                message: "Verify your server's identity",
+                                when: function (previousAnswers) {
+                                    return previousAnswers.hostname.startsWith("https://");
+                                }
+                            },
+                            {
+                                type: "input",
+                                name: "database",
+                                message: "Database filename"
+                            },
+                            {
+                                type: "input",
+                                name: "username",
+                                message: "Database username"
+                            },
+                            {
+                                type: "password",
+                                name: "password",
+                                message: "Database password",
+                                mask: "*"
+                            }
+                        ])];
+                case 1:
+                    data = _c.sent();
+                    HOST = new FMHost_js_1.default(data.hostname, data.timezoneOffset, data.verify);
+                    DATABASE = HOST.database({
+                        database: data.database,
+                        credentials: {
+                            method: "filemaker",
+                            username: data.username,
+                            password: data.password
+                        },
+                        externalSources: []
+                    });
+                    return [4 /*yield*/, DATABASE.login()
+                        // Create file write stream
+                    ];
+                case 2:
+                    _c.sent();
+                    stream = fs.createWriteStream("./types.ts");
+                    return [4 /*yield*/, DATABASE.listLayouts()];
+                case 3:
+                    layouts = _c.sent();
+                    stream.write("import FMHost, {Container, FieldBase, LayoutInterface, Portal} from \"@jd-data-limited/easy-fm\";\n");
+                    stream.write("// " + layouts.length + " layouts found\n\n");
+                    layoutInterfaces = new Map();
+                    _loop_1 = function (layout) {
+                        var metadata, fields, portals, portalsProcessed, interfaceName;
+                        return __generator(this, function (_d) {
+                            switch (_d.label) {
+                                case 0: return [4 /*yield*/, layout.getLayoutMeta()];
+                                case 1:
+                                    metadata = _d.sent();
+                                    fields = processFieldsChunk(metadata.fieldMetaData);
+                                    portals = metadata.portalMetaData;
+                                    portalsProcessed = Object.keys(portals).map(function (portalName) {
+                                        return "".concat(JSON.stringify(portalName), ": Portal<{").concat(processFieldsChunk(portals[portalName]), "}>");
+                                    });
+                                    interfaceName = sub(layout.name) + "LayoutInterface";
+                                    layoutInterfaces.set(layout.name, {
+                                        interfaceName: interfaceName,
+                                        interface: "export interface ".concat(interfaceName, " extends LayoutInterface {\n            fields: {").concat(fields.join(",\n    "), "},\n            portals: {").concat(portalsProcessed.join(",\n   "), "}\n        }")
+                                    });
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _i = 0, layouts_1 = layouts;
+                    _c.label = 4;
+                case 4:
+                    if (!(_i < layouts_1.length)) return [3 /*break*/, 7];
+                    layout = layouts_1[_i];
+                    return [5 /*yield**/, _loop_1(layout)];
+                case 5:
+                    _c.sent();
+                    _c.label = 6;
+                case 6:
+                    _i++;
+                    return [3 /*break*/, 4];
+                case 7:
+                    layoutInterfaceLinks = [];
+                    for (_a = 0, layoutInterfaces_1 = layoutInterfaces; _a < layoutInterfaces_1.length; _a++) {
+                        layout = layoutInterfaces_1[_a];
+                        layoutInterfaceLinks.push([
+                            "".concat(JSON.stringify(layout[0]), ": ").concat(layout[1].interfaceName),
+                            "".concat(sub(camelToSnakeCase(layout[0]).toUpperCase().replace(" ", "_")), ": HOST.getLayout<").concat(layout[1].interfaceName, ">(").concat(JSON.stringify(layout[0]), ")")
+                        ]);
+                    }
+                    stream.write(safeStringInjection(templateObject_1 || (templateObject_1 = __makeTemplateObject(["const HOST = new FMHost(", ", ", ", ", ");"], ["const HOST = new FMHost(", ", ", ", ", ");"])), data.hostname, data.timezoneOffset, data.verify));
+                    stream.write("HOST.database<{layouts:{".concat(layoutInterfaceLinks.map(function (i) { return i[0]; }).join(","), "}}>();"));
+                    stream.write("\n\n");
+                    stream.write("const LAYOUTS = {".concat(layoutInterfaceLinks.map(function (i) { return i[1]; }).join(","), "};"));
+                    for (_b = 0, layoutInterfaces_2 = layoutInterfaces; _b < layoutInterfaces_2.length; _b++) {
+                        layout = layoutInterfaces_2[_b];
+                        stream.write("\n\n");
+                        stream.write(layout[1].interface + ";");
+                    }
+                    // StructureKind
+                    //
+                    // const project = new Project({
+                    //     tsConfigFilePath: "../tsconfig.json"
+                    // })
+                    // project.resolveSourceFileDependencies()
+                    return [4 /*yield*/, DATABASE.logout()];
+                case 8:
+                    // StructureKind
+                    //
+                    // const project = new Project({
+                    //     tsConfigFilePath: "../tsconfig.json"
+                    // })
+                    // project.resolveSourceFileDependencies()
+                    _c.sent();
+                    console.log("DONE! Wrote database types to ./types.ts");
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.generateTypesCLI = generateTypesCLI;
+var templateObject_1;

package/src/bin/generateTypes.ts

@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2024. See LICENSE file for more information
+ */
+
+import {ApiFieldMetadata, ApiFieldResultTypes} from "../models/apiResults.js";
+import inquirer from 'inquirer';
+import FMHost from "../connection/FMHost.js";
+import * as fs from "fs";
+
+function sub(str: string) {
+    return str
+        .replace(/[^a-zA-Z0-9_]/g, "") // Remove non-alphanumeric characters
+        .replace(/^[0-9]+/g, '') // Removing leading numbers
+}
+
+function generateFieldType(field: ApiFieldMetadata) {
+    switch (field.result) {
+        case ApiFieldResultTypes.TEXT:
+            return "FieldBase<string>"
+        case ApiFieldResultTypes.CONTAINER:
+            return "FieldBase<Container>"
+        case ApiFieldResultTypes.DATE:
+            return "FieldBase<Date>"
+        case ApiFieldResultTypes.NUMBER:
+            return "FieldBase<number>"
+        case ApiFieldResultTypes.TIME:
+            return "FieldBase<Date>"
+        case ApiFieldResultTypes.TIMESTAMP:
+            return "FieldBase<Date>"
+    }
+}
+
+function processFieldsChunk(fields: ApiFieldMetadata[]) {
+    let existing_fields: string[] = []
+    fields = fields.filter(field => {
+        if (existing_fields.includes(field.name)) return false
+        existing_fields.push(field.name)
+        return true
+    })
+
+    return fields.map(field => {
+        return JSON.stringify(field.name) + ": " + generateFieldType(field)
+    })
+}
+
+function camelToSnakeCase(str: string) {
+    return str.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
+}
+
+function safeStringInjection(str: TemplateStringsArray, ...args: {toString(): string}[]) {
+    let result = "";
+    for (let i = 0; i < str.length; i++) {
+        result += str[i];
+        if (i < args.length) {
+            result += JSON.stringify(args[i].toString());
+        }
+    }
+    return result;
+}
+
+export async function generateTypesCLI() {
+    process.stdout.write('\x1Bc');
+    console.log("For this tool to work, you are required to have access to an account on the target database.\n" +
+        "This account must have the fmrest extended privilege enabled.\n" +
+        "This tool can only export type interfaces for layouts that the given account has access to.")
+    console.log("\n")
+
+    const data = await inquirer.prompt([
+        {
+            type: "input",
+            name: "hostname",
+            message: "The IP address/domain of your FileMaker server (must start with either http:// or https://)",
+            validate(input: any): boolean | string | Promise<boolean | string> {
+                return input.startsWith("http://") || input.startsWith("https://") || "Please enter a valid IP address/domain starting with http:// or https://";
+            }
+        },
+        {
+            type: "number",
+            name: "timezoneOffset",
+            message: "Server timezone offset (minutes)",
+            default: 0 - (new Date()).getTimezoneOffset()
+        },
+        {
+            type: "confirm",
+            name: "verify",
+            default: true,
+            message: "Verify your server's identity",
+            when(previousAnswers) {
+                return previousAnswers.hostname.startsWith("https://")
+            }
+        },
+        {
+            type: "input",
+            name: "database",
+            message: "Database filename"
+        },
+        {
+            type: "input",
+            name: "username",
+            message: "Database username"
+        },
+        {
+            type: "password",
+            name: "password",
+            message: "Database password",
+            mask: "*"
+        }
+    ])
+
+    const HOST = new FMHost(data.hostname, data.timezoneOffset, data.verify)
+    const DATABASE = HOST.database({
+        database: data.database,
+        credentials: {
+            method: "filemaker",
+            username: data.username,
+            password: data.password
+        },
+        externalSources: []
+    })
+
+    await DATABASE.login()
+    // Create file write stream
+    const stream = fs.createWriteStream("./types.ts")
+    let layouts = await DATABASE.listLayouts()
+
+    stream.write(`import FMHost, {Container, FieldBase, LayoutInterface, Portal} from "@jd-data-limited/easy-fm";\n`)
+    stream.write("// " + layouts.length + " layouts found\n\n")
+
+    let layoutInterfaces = new Map<string, {
+        interfaceName: string,
+        interface: string
+    }>()
+    for (let layout of layouts) {
+        let metadata = await layout.getLayoutMeta()
+        let fields = processFieldsChunk(metadata.fieldMetaData)
+
+        let portals = metadata.portalMetaData
+        let portalsProcessed = Object.keys(portals).map(portalName => {
+            return `${JSON.stringify(portalName)}: Portal<{${processFieldsChunk(
+                portals[portalName]
+            )}}>`
+        })
+
+        let interfaceName = sub(layout.name) + "LayoutInterface"
+        layoutInterfaces.set(layout.name, {
+            interfaceName,
+            interface: `export interface ${interfaceName} extends LayoutInterface {
+            fields: {${fields.join(",\n    ")}},
+            portals: {${portalsProcessed.join(",\n   ")}}
+        }`
+        })
+    }
+
+    let layoutInterfaceLinks: [string, string][] = []
+    for (let layout of layoutInterfaces) {
+        layoutInterfaceLinks.push([
+            `${JSON.stringify(layout[0])}: ${layout[1].interfaceName}`,
+            `${sub(camelToSnakeCase(layout[0]).toUpperCase().replace(" ", "_"))}: HOST.getLayout<${layout[1].interfaceName}>(${JSON.stringify(layout[0])})`
+        ])
+    }
+
+    stream.write(safeStringInjection`const HOST = new FMHost(${data.hostname}, ${data.timezoneOffset}, ${data.verify});`)
+    stream.write(`HOST.database<{layouts:{${
+        layoutInterfaceLinks.map(i => i[0]).join(",")
+    }}}>();`)
+
+    stream.write("\n\n")
+    stream.write(`const LAYOUTS = {${
+        layoutInterfaceLinks.map(i => i[1]).join(",")
+    }};`)
+
+    for (let layout of layoutInterfaces) {
+        stream.write("\n\n")
+        stream.write(layout[1].interface + ";")
+    }
+
+    // StructureKind
+    //
+    // const project = new Project({
+    //     tsConfigFilePath: "../tsconfig.json"
+    // })
+    // project.resolveSourceFileDependencies()
+
+    await DATABASE.logout()
+    console.log("DONE! Wrote database types to ./types.ts")
+}

package/src/connection/FMHost.js

@@ -8,7 +8,16 @@ export default class FMHost {
     hostname;
     timezoneOffset;
     verify;
-    metadata;
+    metadata = {
+        productInfo: {
+            buildDate: new Date(),
+            name: "",
+            version: "",
+            dateFormat: "",
+            timeFormat: "",
+            timeStampFormat: ""
+        }
+    };
     constructor(_hostname, timezoneOffset = 0 - (new Date()).getTimezoneOffset(), verify = true) {
         if (!(/^https?:\/\//).test(_hostname))
             throw "hostname MUST begin with either http:// or https://";
@@ -27,7 +36,7 @@ export default class FMHost {
         });
         let data = await _fetch.json();
         // console.log(data.messages[0])
-        if (data.messages[0].code === "0") {
+        if (data.messages[0].code === "0" && data.response) {
             return data.response.databases;
         }
         else {
@@ -46,7 +55,7 @@ export default class FMHost {
         });
         let data = await _fetch.json();
         // console.log(data.messages[0])
-        if (data.messages[0].code === "0") {
+        if (data.messages[0].code === "0" && data.response) {
             this.metadata = data.response;
             return data.response;
         }

package/src/connection/FMHost.ts

@@ -20,7 +20,16 @@ export default class FMHost implements HostBase {
     readonly hostname: string
     readonly timezoneOffset: number
     readonly verify: boolean
-    metadata: FMHostMetadata
+    metadata: FMHostMetadata = {
+        productInfo: {
+            buildDate: new Date(),
+            name: "",
+            version: "",
+            dateFormat: "",
+            timeFormat: "",
+            timeStampFormat: ""
+        }
+    }
 
     constructor(_hostname: string, timezoneOffset = 0 - (new Date()).getTimezoneOffset(), verify = true) {
         if (!(/^https?:\/\//).test(_hostname)) throw "hostname MUST begin with either http:// or https://"
@@ -42,7 +51,7 @@ export default class FMHost implements HostBase {
         let data = await _fetch.json() as ApiResults<{databases: any}>
         // console.log(data.messages[0])
 
-        if (data.messages[0].code === "0") {
+        if (data.messages[0].code === "0" && data.response) {
             return data.response.databases
         }
         else {
@@ -64,7 +73,7 @@ export default class FMHost implements HostBase {
         let data = await _fetch.json() as ApiResults<FMHostMetadata>
         // console.log(data.messages[0])
 
-        if (data.messages[0].code === "0") {
+        if (data.messages[0].code === "0" && data.response) {
             this.metadata = data.response
             return data.response
         }

package/src/connection/database.js

@@ -93,14 +93,14 @@ export class Database extends EventEmitter {
         options.rejectUnauthorized = this.host.verify;
         let _fetch = await fetch(url, options);
         if (_fetch.headers.get('set-cookie')) {
-            for (let cookie of _fetch.headers.get('set-cookie')) {
+            for (let cookie of _fetch.headers.get('set-cookie') || []) {
                 let cookie_split = cookie.split("=");
                 this.cookies[cookie_split[0]] = cookie_split[1];
             }
         }
         let data = await _fetch.json();
         // Remove response if it is empty. This makes checking for an empty response easier
-        if (Object.keys(data.response).length === 0)
+        if (data.response && Object.keys(data.response).length === 0)
             delete data.response;
         // console.log(data.messages[0])
         if (data.messages[0].code === "952" && autoRelogin) {
@@ -160,7 +160,7 @@ export class Database extends EventEmitter {
                         let cookie_split = cookie.split("=");
                         this.cookies[cookie_split[0]] = cookie_split[1];
                     }
-                    res.headers['set-cookie'] = null;
+                    res.headers['set-cookie'] = undefined;
                 }
             };
             // Automatically switch between the http and https modules, based on which is needed