@technicity/data-service-generator 0.14.1 → 0.14.3

package/dist/runtime/lib/stringifyWhere.test.js

@@ -0,0 +1,236 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const stringifyWhere_1 = require("./stringifyWhere");
+(0, globals_1.describe)("stringifyWhere", () => {
+    const table = "Usr";
+    const dialect = "mysql";
+    const args = {};
+    (0, globals_1.test)("should work", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: 2, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` = 2 AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle empty object", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({ where: {}, table, dialect, args });
+        strict_1.default.deepEqual(result, "");
+    });
+    (0, globals_1.test)("should handle $and", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { $and: [{ valid: true }, { text: "foo" }] },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "(Usr.`valid` = 1 AND Usr.`text` = 'foo')");
+    });
+    (0, globals_1.test)("should handle $or", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { $or: [{ valid: true }, { text: "foo" }] },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "(Usr.`valid` = 1 OR Usr.`text` = 'foo')");
+    });
+    (0, globals_1.test)("should handle null", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: null },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` IS NULL");
+    });
+    (0, globals_1.test)("should handle $neq", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $neq: 2 }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` != 2 AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $gt", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $gt: 2 }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` > 2 AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $gte", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $gte: 2 }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` >= 2 AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $lt", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $lt: 2 }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` < 2 AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $lte", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $lte: 2 }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` <= 2 AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $like", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { text: { $like: "%foo%" } },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`text` LIKE '%foo%'");
+    });
+    (0, globals_1.test)("should handle $nlike", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { text: { $nlike: "%foo%" } },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`text` NOT LIKE '%foo%'");
+    });
+    (0, globals_1.test)("should handle $in", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $in: [1, 2] }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` IN (1,2) AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle empty $in", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $in: [] }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "(1=0) AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $nin", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $nin: [1, 2] }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` NOT IN (1,2) AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle empty $nin", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $nin: [] }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "(1=1) AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $btwn", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $btwn: [1, 20] }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` BETWEEN 1 AND 20 AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $nbtwn", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $nbtwn: [1, 20] }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` NOT BETWEEN 1 AND 20 AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle nested $and and $or", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: {
+                $and: [
+                    { userId: { $gt: 2 } },
+                    { $or: [{ text: { $like: "foo" } }, { text: { $like: "bar" } }] },
+                    { $and: [{ lala: "lala" }, { oioi: "oioi" }] }
+                ]
+            },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "(Usr.`userId` > 2 AND (Usr.`text` LIKE 'foo' OR Usr.`text` LIKE 'bar') AND (Usr.`lala` = 'lala' AND Usr.`oioi` = 'oioi'))");
+    });
+    (0, globals_1.test)("should throw on invalid operator", () => {
+        strict_1.default.throws(() => (0, stringifyWhere_1.stringifyWhere)({
+            where: { foo: { $foo: 3 } },
+            table,
+            dialect,
+            args
+        }), (error) => {
+            (0, strict_1.default)(error instanceof Error);
+            (0, strict_1.default)(error.message.startsWith("Invalid operator:"));
+            return true;
+        });
+    });
+    (0, globals_1.test)("should throw on more than 1 key for $and", () => {
+        strict_1.default.throws(() => (0, stringifyWhere_1.stringifyWhere)({
+            where: { $and: [{ foo: "bar" }, { bar: "baz" }], foo: "bar" },
+            table,
+            dialect,
+            args
+        }), (error) => {
+            (0, strict_1.default)(error instanceof Error);
+            (0, strict_1.default)(error.message.startsWith("Must have 1 key:"));
+            return true;
+        });
+    });
+    (0, globals_1.test)("ignores undefined values", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { $or: [{ foo: "bar" }, { bar: null }, { baz: undefined }] },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "(Usr.`foo` = 'bar' OR Usr.`bar` IS NULL)");
+    });
+    (0, globals_1.test)("handles empty $and", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { $and: [] },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "");
+    });
+    (0, globals_1.test)("handles empty $or", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { $or: [] },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "");
+    });
+});

package/dist/runtime/lib/typeCastMSSQL.js

@@ -1,7 +1,30 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.typeCastMSSQL = void 0;
-const mssql = require("mssql");
+const mssql = __importStar(require("mssql"));
 // TODO: see https://github.com/tediousjs/node-mssql/pull/1171
 function typeCastMSSQL(customTypeCast) {
     return function (result, meta) {

package/dist/traverseFieldArgs.d.ts

@@ -1,2 +1,2 @@
-import { IArgs, IField } from "./runtime/IRuntime";
-export declare function traverseFieldArgs(fields: IField[], cb: (args: IArgs | undefined) => IArgs): void;
+import { IArgs, TSelect } from "./runtime/IRuntime";
+export declare function traverseFieldArgs(fields: TSelect, cb: (args: IArgs | undefined) => IArgs): void;

package/dist/traverseFieldArgs.js

@@ -2,12 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.traverseFieldArgs = void 0;
 function traverseFieldArgs(fields, cb) {
-    for (let x of fields) {
+    const values = Object.values(fields);
+    for (let x of values) {
         if (typeof x !== "object") {
             continue;
         }
-        x.args = cb(x.args);
-        traverseFieldArgs(x.fields, cb);
+        const fields = x.$fields;
+        if (fields == null) {
+            continue;
+        }
+        cb(x);
+        traverseFieldArgs(fields, cb);
     }
 }
 exports.traverseFieldArgs = traverseFieldArgs;

package/dist/traverseFieldArgs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/traverseFieldArgs.test.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const _1 = require(".");
+const addWhereValidTrue_1 = require("../test/addWhereValidTrue");
+(0, globals_1.describe)("traverseFieldArgs", () => {
+    (0, globals_1.test)("should work", () => {
+        const fields = {
+            id: true,
+            uuid: true,
+            business: { $fields: { id: true, uuid: true, name: true } },
+            sessionList: {
+                $fields: {
+                    id: true,
+                    archived: true,
+                    fooList: { $fields: { id: true, uuid: true } }
+                },
+                $where: { archived: false },
+                $orderBy: { id: "desc" }
+            },
+            usrList: {
+                $fields: { firstName: true, lastName: true, password: true },
+                $where: { valid: false, archived: false },
+                $orderBy: { id: "desc" }
+            }
+        };
+        (0, _1.traverseFieldArgs)(fields, addWhereValidTrue_1.addWhereValidTrue);
+        strict_1.default.deepEqual(fields, {
+            id: true,
+            uuid: true,
+            business: {
+                $fields: { id: true, uuid: true, name: true },
+                $where: { valid: true }
+            },
+            sessionList: {
+                $fields: {
+                    id: true,
+                    archived: true,
+                    fooList: { $fields: { id: true, uuid: true }, $where: { valid: true } }
+                },
+                $where: { valid: true, archived: false },
+                $orderBy: { id: "desc" }
+            },
+            usrList: {
+                $fields: { firstName: true, lastName: true, password: true },
+                // Should not be overwritten
+                $where: { valid: false, archived: false },
+                $orderBy: { id: "desc" }
+            }
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@technicity/data-service-generator",
-  "version": "0.14.1",
+  "version": "0.14.3",
   "main": "./dist/index.js",
   "files": [
     "dist"
@@ -25,7 +25,7 @@
     "json-schema-to-typescript": "10.1.5",
     "lodash": "^4.17.20",
     "loglevel": "^1.8.1",
-    "mssql": "^6.3.1",
+    "mssql": "10.0.0",
     "mysql": "^2.18.1",
     "prettier": "^2.1.2",
     "sqlstring": "^2.3.2",
@@ -39,7 +39,7 @@
     "@swc/jest": "^0.2.24",
     "@types/fs-extra": "9.0.13",
     "@types/lodash": "4.14.177",
-    "@types/mssql": "^6.0.7",
+    "@types/mssql": "8.1.2",
     "@types/node": "^18.14.1",
     "@types/prettier": "^2.1.5",
     "@types/sqlstring": "^2.2.1",
@@ -48,8 +48,5 @@
     "sinon": "12.0.1",
     "testcontainers": "^9.1.3",
     "typescript": "4.6.4"
-  },
-  "resolutions": {
-    "xml2js": "0.5.0"
   }
 }

package/dist/ksql.d.ts

@@ -1,15 +0,0 @@
-declare type THeaders = {
-    [k: string]: any;
-};
-export declare class KSQL {
-    hostname: string;
-    port: number;
-    headers?: THeaders;
-    constructor(options: {
-        hostname: string;
-        port: number;
-        headers?: THeaders;
-    });
-    streamQuery(s: string): Promise<any[]>;
-}
-export {};

package/dist/ksql.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KSQL = void 0;
-const http2 = require("http2");
-class KSQL {
-    constructor(options) {
-        this.hostname = options.hostname;
-        this.port = options.port;
-        this.headers = options.headers;
-    }
-    async streamQuery(s) {
-        return new Promise((resolve, reject) => {
-            const reqBody = JSON.stringify({
-                sql: s,
-                properties: {
-                    "ksql.streams.auto.offset.reset": "earliest",
-                    "ksql.query.pull.table.scan.enabled": true,
-                },
-            });
-            const client = http2.connect(`https://${this.hostname}:${this.port}`);
-            const req = client.request({
-                [http2.constants.HTTP2_HEADER_SCHEME]: "https",
-                "Content-Type": "application/json",
-                "Content-Length": reqBody.length,
-                ":method": "POST",
-                ":path": `/query-stream`,
-                ...this.headers,
-            });
-            req.setEncoding("utf8");
-            let columnNames = [];
-            let rows = [];
-            req.on("data", (d) => {
-                const resData = JSON.parse(d);
-                if (resData.error_code) {
-                    return reject(new Error(resData.message));
-                }
-                if (resData.columnNames) {
-                    columnNames = resData.columnNames;
-                }
-                else {
-                    let out = {};
-                    resData.forEach((rd, i) => {
-                        out[columnNames[i]] = rd;
-                    });
-                    rows.push(out);
-                }
-            });
-            req.on("close", () => resolve(rows));
-            req.on("error", (error) => reject(error));
-            req.write(reqBody);
-            req.end();
-        });
-    }
-}
-exports.KSQL = KSQL;

package/dist/runtime/RuntimeKSQL.d.ts

@@ -1,19 +0,0 @@
-import type { IRuntime, TMiddleware, TResolveParams, IArtifacts, TDbCall } from "./IRuntime";
-import { KSQL } from "../ksql";
-declare type TGetTableName = (table: string) => string;
-export declare class RuntimeKSQL implements IRuntime {
-    #private;
-    constructor(clientOpts: ConstructorParameters<typeof KSQL>[0], otherOpts: {
-        getBaseTableName: TGetTableName;
-        getMaterializedViewName: TGetTableName;
-        doNotUseMaterializedViews?: boolean;
-        _dbCall: TDbCall;
-    }, artifacts: IArtifacts);
-    resolve(input: TResolveParams): Promise<any>;
-    $queryRaw(sql: string, values?: any[]): Promise<any>;
-    $use(middleware: TMiddleware): Promise<void>;
-    $whereNeedsProcessing(where: any): boolean;
-    $prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<{}>;
-    $shutdown(): Promise<void>;
-}
-export {};