@technicity/data-service-generator 0.22.2 → 0.23.0-next.0

package/dist/src/runtime/lib/addNullFallbacks.test.js

@@ -0,0 +1,206 @@
+"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 addNullFallbacks_1 = require("./addNullFallbacks");
+(0, globals_1.describe)("addNullFallbacks", () => {
+    // The actual AST has other fields like `args` that
+    // aren't relevant to the function
+    const sqlAST = {
+        type: "table",
+        name: "Session",
+        as: "Session",
+        fieldName: "session",
+        grabMany: false,
+        children: [
+            {
+                type: "column",
+                name: "id",
+                fieldName: "id",
+                as: "a"
+            },
+            {
+                type: "table",
+                name: "SessionPlan",
+                as: "SessionPlan",
+                fieldName: "sessionPlan",
+                grabMany: false,
+                children: [
+                    {
+                        type: "column",
+                        name: "id",
+                        fieldName: "id",
+                        as: "a"
+                    },
+                    {
+                        type: "column",
+                        name: "uuid",
+                        fieldName: "uuid",
+                        as: "c"
+                    },
+                    {
+                        type: "column",
+                        name: "id",
+                        fieldName: "id",
+                        as: "a"
+                    }
+                ]
+            }
+        ]
+    };
+    (0, globals_1.test)("should work for object", () => {
+        const data = {
+            id: 1,
+            sessionPlanId: null,
+            sessionPlan: undefined
+        };
+        (0, addNullFallbacks_1.addNullFallbacks)(sqlAST, data);
+        strict_1.default.deepEqual(data, {
+            id: 1,
+            sessionPlanId: null,
+            sessionPlan: null
+        });
+    });
+    (0, globals_1.test)("should work for array", () => {
+        const data = [
+            {
+                id: 1,
+                sessionPlanId: null,
+                sessionPlan: undefined
+            },
+            {
+                id: 2,
+                sessionPlanId: null,
+                sessionPlan: undefined
+            }
+        ];
+        (0, addNullFallbacks_1.addNullFallbacks)(sqlAST, data);
+        strict_1.default.deepEqual(data, [
+            {
+                id: 1,
+                sessionPlanId: null,
+                sessionPlan: null
+            },
+            {
+                id: 2,
+                sessionPlanId: null,
+                sessionPlan: null
+            }
+        ]);
+    });
+    (0, globals_1.test)("should work for nested array", () => {
+        const sqlAST = {
+            type: "table",
+            name: "Session",
+            as: "Session",
+            fieldName: "session",
+            grabMany: false,
+            children: [
+                {
+                    type: "column",
+                    name: "id",
+                    fieldName: "id",
+                    as: "a"
+                },
+                {
+                    type: "table",
+                    name: "SessionPlan",
+                    as: "SessionPlan",
+                    fieldName: "sessionPlan",
+                    grabMany: false,
+                    children: [
+                        {
+                            type: "column",
+                            name: "id",
+                            fieldName: "id",
+                            as: "a"
+                        },
+                        {
+                            type: "column",
+                            name: "uuid",
+                            fieldName: "uuid",
+                            as: "c"
+                        },
+                        {
+                            type: "column",
+                            name: "id",
+                            fieldName: "id",
+                            as: "a"
+                        },
+                        {
+                            type: "table",
+                            name: "SessionPlan",
+                            as: "SessionPlan",
+                            fieldName: "sessionPlan",
+                            grabMany: false,
+                            children: [
+                                {
+                                    type: "column",
+                                    name: "id",
+                                    fieldName: "id",
+                                    as: "a"
+                                },
+                                {
+                                    type: "column",
+                                    name: "uuid",
+                                    fieldName: "uuid",
+                                    as: "c"
+                                },
+                                {
+                                    type: "column",
+                                    name: "id",
+                                    fieldName: "id",
+                                    as: "a"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        };
+        const data = [
+            {
+                id: 1,
+                sessionPlanId: 1,
+                sessionPlan: {
+                    id: 1,
+                    uuid: "stub",
+                    sessionPlan: undefined
+                }
+            },
+            {
+                id: 2,
+                sessionPlanId: 2,
+                sessionPlan: {
+                    id: 2,
+                    uuid: "stub",
+                    sessionPlan: undefined
+                }
+            }
+        ];
+        (0, addNullFallbacks_1.addNullFallbacks)(sqlAST, data);
+        strict_1.default.deepEqual(data, [
+            {
+                id: 1,
+                sessionPlanId: 1,
+                sessionPlan: {
+                    id: 1,
+                    uuid: "stub",
+                    sessionPlan: null
+                }
+            },
+            {
+                id: 2,
+                sessionPlanId: 2,
+                sessionPlan: {
+                    id: 2,
+                    uuid: "stub",
+                    sessionPlan: null
+                }
+            }
+        ]);
+    });
+});

package/dist/src/runtime/lib/cursor.d.ts

@@ -0,0 +1,2 @@
+export declare function encodeCursor(cursor: string): string;
+export declare function decodeCursor(cursor: string): any;

package/dist/src/runtime/lib/cursor.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeCursor = encodeCursor;
+exports.decodeCursor = decodeCursor;
+function encodeCursor(cursor) {
+    return Buffer.from(JSON.stringify(cursor)).toString("base64");
+}
+function decodeCursor(cursor) {
+    return JSON.parse(Buffer.from(cursor, "base64").toString("utf8"));
+}

package/dist/src/runtime/lib/getDateTimeStringMySQL.d.ts

@@ -0,0 +1 @@
+export declare function getDateTimeStringMySQL(dateTimeString: string): string;

package/dist/src/runtime/lib/getDateTimeStringMySQL.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDateTimeStringMySQL = getDateTimeStringMySQL;
+// Assumes input uses zero offset
+function getDateTimeStringMySQL(dateTimeString) {
+    return dateTimeString.replace("T", " ").slice(0, 19);
+}

package/dist/src/runtime/lib/getOrderBy.d.ts

@@ -0,0 +1,5 @@
+import { IArgs, IOrderBy } from "../IRuntime";
+export declare function getOrderBy(args: IArgs | undefined, primaryKey: string): {
+    orderBy: IOrderBy | undefined;
+    flip: boolean;
+};

package/dist/src/runtime/lib/getOrderBy.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrderBy = getOrderBy;
+// https://gist.github.com/pcattori/2bb645d587e45c9fdbcabf5cef7a7106
+function getOrderBy(args, primaryKey) {
+    let out = undefined;
+    let flip = false;
+    if (Array.isArray(args?.$orderBy)) {
+        out = args?.$orderBy.map((x) => {
+            const [column, direction] = Object.entries(x)[0];
+            return { column, direction };
+        });
+    }
+    else if (typeof args?.$orderBy === "object" && args.$orderBy != null) {
+        const [column, direction] = Object.entries(args.$orderBy)[0];
+        out = [{ column, direction }];
+    }
+    if (args?.$paginate?.first != null || args?.$paginate?.last != null) {
+        // If paginating and primaryKey is not in orderBy, add it to end.
+        // Not necessarily "asc"; see flip.
+        if (!out?.find((x) => x.column === primaryKey)) {
+            const orderByPrimaryKey = { column: primaryKey, direction: "asc" };
+            if (out == null) {
+                out = [orderByPrimaryKey];
+            }
+            else {
+                out = out.concat(orderByPrimaryKey);
+            }
+        }
+        flip = getFlip(args);
+        if (flip) {
+            out = flipOrderByDirection(out);
+        }
+    }
+    if (Array.isArray(out)) {
+        for (let x of out) {
+            if (!["asc", "desc"].includes(x.direction)) {
+                throw new Error(`Expected \`asc\` or \`desc\` for \`direction\` but got: ${x.direction}`);
+            }
+        }
+    }
+    return { orderBy: out, flip };
+}
+function getFlip(args) {
+    return args?.$paginate?.last != null;
+}
+function flipOrderByDirection(orderBy) {
+    return orderBy.map((x) => ({ ...x, direction: flipDirection(x.direction) }));
+}
+function flipDirection(direction) {
+    return direction === "asc" ? "desc" : "asc";
+}

package/dist/src/runtime/lib/getSqlAst.d.ts

@@ -0,0 +1,2 @@
+import { IGetSQLASTInput } from "../IRuntime";
+export declare function getSqlAst(input: IGetSQLASTInput): any;

package/dist/src/runtime/lib/getSqlAst.js

@@ -0,0 +1,245 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSqlAst = getSqlAst;
+const SqlString = __importStar(require("sqlstring"));
+// @ts-ignore
+const alias_namespace_1 = __importDefault(require("join-monster/dist/alias-namespace"));
+const _ = __importStar(require("lodash/fp"));
+const getOrderBy_1 = require("./getOrderBy");
+const namespace = new alias_namespace_1.default(true);
+function getSqlAst(input) {
+    const { table, fieldName, fields, args, grabMany, sqlJoin, sqlBatch, junction, getWhere, artifacts, rowWithMatchingCursor, dialect, escapeId } = input;
+    const tableArtifacts = artifacts[table];
+    const primaryKey = tableArtifacts.primaryKey;
+    const format = SqlString.format.bind(SqlString);
+    const orderBy = input.orderBy ?? (0, getOrderBy_1.getOrderBy)(args, primaryKey)?.orderBy;
+    let where = input.where;
+    if (input.where == null) {
+        where = (table, args) => {
+            let argsMapped = args;
+            if (junction != null &&
+                typeof argsMapped?.$where === "object" &&
+                argsMapped.$where != null &&
+                argsMapped.$where[input.table] != null) {
+                argsMapped = _.cloneDeep(argsMapped);
+                argsMapped.$where = argsMapped.$where[input.table];
+            }
+            const whereResult = getWhere(
+            // table is escaped already
+            table, argsMapped, dialect, orderBy, rowWithMatchingCursor);
+            if (whereResult == null) {
+                return undefined;
+            }
+            return whereResult;
+        };
+    }
+    // A unique key needs to be first in children.
+    // https://github.com/join-monster/join-monster/blob/819cd03c8eca3421bf3008594ea84db8fad057d4/src/query-ast-to-sql-ast/index.js#L388
+    // https://github.com/CoursePark/NestHydrationJS#sql-ish-example
+    // https://github.com/CoursePark/NestHydrationJS#ids-that-arent-first-in-definition-properties
+    // For many-to-many batches, the unique key of the junction table should be first.
+    // https://github.com/join-monster/join-monster/blob/819cd03c8eca3421bf3008594ea84db8fad057d4/src/query-ast-to-sql-ast/index.js#L335
+    const children = [];
+    if (input.firstChild != null) {
+        children.push(input.firstChild);
+    }
+    children.push(keyToASTChild(primaryKey, namespace));
+    return {
+        type: "table",
+        name: table,
+        as: table,
+        fieldName,
+        grabMany,
+        junction,
+        sqlJoin,
+        sqlBatch,
+        args,
+        where,
+        orderBy,
+        children: children.concat(Object.entries(fields)
+            .filter(([_, v]) => v !== false)
+            .map(([k, v]) => {
+            const mappedField = tableArtifacts.mappedFields?.[k];
+            const relationField = tableArtifacts.relationFields?.[k];
+            if (mappedField != null) {
+                return {
+                    type: "expression",
+                    sqlExpr: (table) => {
+                        const referencedTableAlias = namespace.generate("table", mappedField.referencedTable);
+                        return format(`(SELECT ?? FROM ?? AS ?? WHERE ??.?? = ${table}.??)`, [
+                            mappedField.name,
+                            mappedField.referencedTable,
+                            referencedTableAlias,
+                            referencedTableAlias,
+                            mappedField.referencedKey,
+                            mappedField.foreignKey
+                        ]);
+                    },
+                    name: k,
+                    fieldName: k,
+                    as: namespace.generate("column", k)
+                };
+            }
+            else if (relationField != null) {
+                const fields = typeof v === "object"
+                    ? v.$fields ??
+                        tableArtifacts.scalarFields.reduce((acc, x) => {
+                            acc[x] = true;
+                            return acc;
+                        }, {})
+                    : tableArtifacts.scalarFields.reduce((acc, x) => {
+                        acc[x] = true;
+                        return acc;
+                    }, {});
+                const args = typeof v === "object" ? v : {};
+                if (relationField.type === "many-to-many") {
+                    const asJunction = namespace.generate("table", relationField.junctionTable);
+                    const uniqueKey = artifacts[relationField.junctionTable].primaryKey;
+                    return getSqlAst({
+                        table: relationField.table,
+                        fieldName: k,
+                        fields,
+                        args,
+                        grabMany: relationField.grabMany,
+                        firstChild: {
+                            ...keyToASTChild(uniqueKey, namespace, asJunction),
+                            // There's either a bug in join-monster, or join-monster doesn't expect a junction table to have a primary key.
+                            // Work around by ensuring a unique name, to avoid e.g. SELECT `UserRole`.`id` AS `b`, `Role`.`id` AS `b`
+                            // Notice the duplicate names in the select. This results in missing rows because the
+                            // shape definition passed into NestHydrationJS will only have 1 `id`.
+                            fieldName: String(Date.now()),
+                            as: String(Date.now())
+                        },
+                        junction: {
+                            sqlTable: relationField.junctionTable,
+                            as: asJunction,
+                            uniqueKey,
+                            where: (table, args) => {
+                                if (typeof args?.$where !== "object" ||
+                                    typeof args?.$where == null ||
+                                    args.$where[relationField.junctionTable] == null) {
+                                    return undefined;
+                                }
+                                const argsMapped = _.cloneDeep(args);
+                                argsMapped.$where =
+                                    argsMapped.$where[relationField.junctionTable];
+                                const whereResult = getWhere(
+                                // table is escaped already
+                                table, argsMapped, dialect, orderBy, rowWithMatchingCursor);
+                                if (whereResult == null) {
+                                    return undefined;
+                                }
+                                return whereResult;
+                            },
+                            // Because we used the where in sqlJoin
+                            // where: () => undefined,
+                            // TODO - where
+                            // sqlJoins: [
+                            //   (t: string, junctionTable: string, args: any) =>
+                            //     `${t}.${escapeId(relationField.relations[0].referencedKey)} = ${junctionTable}.${escapeId(relationField.relations[0].foreignKey)}`,
+                            //   (junctionTable: string, t: string, args: any) =>
+                            //     `${junctionTable}.${escapeId(relationField.relations[1].foreignKey)} = ${t}.${escapeId(relationField.relations[1].referencedKey)}`,
+                            // ],
+                            // We have to use sqlBatch instead of sqlJoin because pagination is not
+                            // supported with `mysql` dialect, and LIMITing the root list means
+                            // sub lists are limited, too.
+                            sqlBatch: {
+                                thisKey: columnToASTChild(relationField.relations[0].foreignKey, namespace, asJunction),
+                                parentKey: columnToASTChild(relationField.relations[0].referencedKey, namespace),
+                                sqlJoin: (junctionTable, t, args) => `${junctionTable}.${escapeId(relationField.relations[1].foreignKey)} = ${t}.${escapeId(relationField.relations[1].referencedKey)}`
+                            }
+                        },
+                        getWhere,
+                        artifacts,
+                        dialect,
+                        escapeId
+                    });
+                }
+                return getSqlAst({
+                    table: relationField.table,
+                    fieldName: k,
+                    fields,
+                    args,
+                    grabMany: relationField.grabMany,
+                    // Because we used the where in sqlJoin
+                    // where: () => undefined,
+                    // sqlJoin: (t1: string, t2: string, args: any) => {
+                    //   let sql = `${t1}.?? = ${t2}.??`;
+                    //   let values = [relationField.relation.foreignKey, relationField.relation.referencedKey];
+                    //   if (args?.$where != null) {
+                    //     const whereResult = getWhere(t2, args);
+                    //     sql += " and " + whereResult.sql;
+                    //     values.push(whereResult.values);
+                    //   }
+                    //   return s.format(sql, values);
+                    // },
+                    // We have to use sqlBatch instead of sqlJoin because pagination is not
+                    // supported with `mysql` dialect, and LIMITing the root list means
+                    // sub lists are limited, too.
+                    sqlBatch: {
+                        thisKey: columnToASTChild(relationField.relation.referencedKey, namespace),
+                        parentKey: columnToASTChild(relationField.relation.foreignKey, namespace)
+                    },
+                    getWhere,
+                    artifacts,
+                    dialect,
+                    escapeId
+                });
+            }
+            else {
+                return columnToASTChild(k, namespace);
+            }
+        }))
+    };
+}
+function keyToASTChild(key, namespace, fromOtherTable) {
+    if (Array.isArray(key)) {
+        const clumsyName = toClumsyName(key);
+        return {
+            type: "composite",
+            name: key,
+            fieldName: clumsyName,
+            as: namespace.generate("column", clumsyName),
+            fromOtherTable
+        };
+    }
+    return columnToASTChild(key, namespace, fromOtherTable);
+}
+function columnToASTChild(columnName, namespace, fromOtherTable) {
+    return {
+        type: "column",
+        name: columnName,
+        fieldName: columnName,
+        as: namespace.generate("column", columnName),
+        fromOtherTable
+    };
+}
+function toClumsyName(keyArr) {
+    return keyArr.map((name) => name.slice(0, 3)).join("#");
+}

package/dist/src/runtime/lib/getWhere.d.ts

@@ -0,0 +1,2 @@
+import type { IOrderBy, IDialect } from "../IRuntime";
+export declare function getWhere(table: string, args: any, dialect: IDialect, orderBy?: IOrderBy | undefined, rowWithMatchingCursor?: any): string | null;

package/dist/src/runtime/lib/getWhere.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWhere = getWhere;
+const stringifyWhere_1 = require("./stringifyWhere");
+function getWhere(
+// Note: `table` is not escaped in getWhere, so it should be escaped beforehand.
+table, args, dialect, orderBy, rowWithMatchingCursor) {
+    if (args?.$where == null && args?.$paginate == null) {
+        return null;
+    }
+    let where = args?.$where ?? {};
+    return ((0, stringifyWhere_1.stringifyWhere)({
+        where,
+        table,
+        dialect,
+        args,
+        orderBy,
+        rowWithMatchingCursor,
+    }) || null);
+}

package/dist/src/runtime/lib/shared.d.ts

@@ -0,0 +1,13 @@
+import { type IGetSQLASTInput, type IArtifacts, type IDialect, type TDbCall, type TFormatQuery, type TBeginTransaction, type TContext, type TMiddleware, type TResolveParams } from "../IRuntime";
+import Cache from "../Cache";
+export declare function resolve(input: TResolveParams, dbCall: TDbCall, formatQuery: TFormatQuery, beginTransaction: TBeginTransaction, dialect: IDialect, middlewareHandler: MiddlewareHandler<TMiddleware>, context: TContext, cache?: Cache): Promise<any>;
+export declare class MiddlewareHandler<M extends Function> {
+    private _middlewares;
+    register(middleware: M): void;
+    get(id: number): M | undefined;
+    has(id: number): boolean;
+    length(): number;
+}
+export declare function postProcess(data: any, fields: IGetSQLASTInput["fields"], shouldRemoveExtraKeys: boolean): void;
+export declare function whereNeedsProcessing(where: any): boolean;
+export declare function _prepareWhere(artifacts: IArtifacts, table: string, data: any, dbCall: TDbCall, formatQuery: TFormatQuery): Promise<{}>;