@technicity/data-service-generator 0.2.8 → 0.4.1

package/dist/stringifyWhere.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringifyWhere = void 0;
+exports.getEscape = exports.getEscapeId = exports.stringifyWhere = void 0;
 const _ = require("lodash/fp");
 const MySqlString = require("sqlstring");
 // @ts-ignore
 const TSqlString = require("tsqlstring");
-const cursor_1 = require("./cursor");
 function stringifyWhere(input) {
-    const { where, table, dialect, args, primaryKey, orderBy, rowWithCursorId, } = input;
+    const { where, table, dialect, args, orderBy, rowWithCursorId } = input;
     const escapeId = getEscapeId(dialect);
     const escape = getEscape(dialect);
     let result = _stringifyWhere(where, table, escapeId, escape, "");
@@ -15,8 +14,6 @@ function stringifyWhere(input) {
         table,
         args,
         orderBy,
-        primaryKey,
-        dialect,
         escapeId,
         escape,
         rowWithCursorId,
@@ -162,54 +159,46 @@ function getOperatorNeq(value) {
 //   return { k, v };
 // }
 function stringifyPaginationWhere(input) {
-    const { table, args, orderBy, primaryKey, dialect, escapeId, escape, rowWithCursorId, } = input;
-    if (args?.$paginate?.after != null || args?.$paginate?.before != null) {
-        const idDir = args.$paginate.after != null ? "asc" : "desc";
-        const cursor = args.$paginate.after != null
-            ? args.$paginate.after
-            : args.$paginate.before;
-        const getCompOp = (dir) => (dir === "asc" ? ">" : "<");
-        if (orderBy == null) {
-            return `${table}.${escapeId(primaryKey)} ${getCompOp(idDir)} ${cursor_1.decodeCursor(cursor)}`;
+    const { table, args, orderBy, escapeId, escape, rowWithCursorId } = input;
+    if (args?.$paginate?.after == null && args?.$paginate?.before == null) {
+        return "";
+    }
+    if (rowWithCursorId == null) {
+        return "";
+    }
+    // orderBy should never be null because of getOrderBy, but add a check.
+    if (orderBy == null) {
+        throw new Error("orderBy cannot be null when paginating");
+    }
+    function getCompOp(dir) {
+        return dir === "asc" ? ">" : "<";
+    }
+    function printValue(v) {
+        if (v === true) {
+            v = 1;
         }
-        else {
-            const orders = orderBy
-                .filter((x) => x.column !== primaryKey)
-                .concat({ column: primaryKey, direction: "asc" });
-            function printValue(v) {
-                if (v === true) {
-                    v = 1;
-                }
-                if (v === false) {
-                    v = 0;
-                }
-                return escape(v);
-            }
-            const cond = orders
-                .map(({ direction }, i) => {
-                const a = orders
-                    .slice(0, i + 1)
-                    .map(({ column: col2 }, j, arr) => {
-                    const field = `${table}.${escapeId(col2)}`;
-                    const op = j === arr.length - 1 ? getCompOp(direction) : "=";
-                    let v = rowWithCursorId[col2];
-                    // TODO?
-                    if (dialect === "mssql" && v instanceof Date) {
-                        // Clone, since setMinutes mutates
-                        v = new Date(v.valueOf());
-                        v.setMinutes(v.getMinutes() + new Date().getTimezoneOffset());
-                    }
-                    v = printValue(v);
-                    return `${field} ${op} ${v}`;
-                })
-                    .join(" AND ");
-                return "(" + a + ")";
-            })
-                .join(" OR ");
-            return "(" + cond + ")";
+        if (v === false) {
+            v = 0;
         }
+        return escape(v);
     }
-    return "";
+    // https://gist.github.com/pcattori/2bb645d587e45c9fdbcabf5cef7a7106
+    const cond = orderBy
+        .map(({ column, direction }, i) => {
+        let a = orderBy.slice(0, i).map(({ column: col2 }) => {
+            const field = `${table}.${escapeId(col2)}`;
+            const op = "=";
+            const v = printValue(rowWithCursorId[col2]);
+            return `${field} ${op} ${v}`;
+        });
+        const field = `${table}.${escapeId(column)}`;
+        const op = getCompOp(direction);
+        const v = printValue(rowWithCursorId[column]);
+        a.push(`${field} ${op} ${v}`);
+        return "(" + a.join(" AND ") + ")";
+    })
+        .join(" OR ");
+    return "(" + cond + ")";
 }
 function getEscapeId(dialect) {
     if (dialect === "mysql") {
@@ -220,6 +209,7 @@ function getEscapeId(dialect) {
     }
     throw new Error("Unsupported dialect: " + dialect);
 }
+exports.getEscapeId = getEscapeId;
 function getEscape(dialect) {
     if (dialect === "mysql") {
         return MySqlString.escape.bind(MySqlString);
@@ -229,3 +219,4 @@ function getEscape(dialect) {
     }
     throw new Error("Unsupported dialect: " + dialect);
 }
+exports.getEscape = getEscape;

package/dist/types.d.ts

@@ -0,0 +1,142 @@
+import { getWhere } from "./getWhere";
+export declare type IDialect = "mysql" | "mssql" | "ksql";
+export declare type TDbCall = (q: string) => Promise<any>;
+export declare type TFormatQuery = (q: string, values: any[]) => string;
+export declare type ISupplementClientOpts = boolean;
+export declare type IOrderBy = Array<{
+    column: string;
+    direction: any;
+}>;
+export declare type IArgs = {
+    [k: string]: any;
+};
+declare type IField = string | {
+    name: string;
+    as?: string;
+    fields: Array<IField>;
+    args?: IArgs;
+    transform?: (record: any) => any;
+};
+declare type IWhere = (table: string, args: IArgs) => string | undefined;
+declare type IASTChildColumn = {
+    type: "column";
+    name: string;
+    fieldName: string;
+    as: string;
+    fromOtherTable?: string | undefined;
+};
+declare type IASTChildComposite = {
+    type: "composite";
+    name: string[];
+    fieldName: string;
+    as: string;
+    fromOtherTable?: string | undefined;
+};
+declare type ISqlJoin = (t1: string, t2: string, args: IArgs) => string;
+declare type ISqlBatch = {
+    thisKey: IASTChildColumn;
+    parentKey: IASTChildColumn;
+};
+declare type IJunction = {
+    sqlTable: string;
+    as: string;
+    uniqueKey: string | string[];
+    where?: IWhere;
+    sqlBatch: {
+        thisKey: IASTChildColumn;
+        parentKey: IASTChildColumn;
+        sqlJoin: ISqlJoin;
+    };
+} | {
+    sqlTable: string;
+    as: string;
+    where?: IWhere;
+    sqlJoins: Array<ISqlJoin>;
+};
+export declare type IGetSQLASTInput = {
+    table: string;
+    fieldName: string;
+    fields: Array<IField>;
+    args?: IArgs;
+    where?: IWhere;
+    sqlJoin?: ISqlJoin;
+    sqlBatch?: ISqlBatch;
+    junction?: IJunction;
+    grabMany: boolean;
+    getWhere: typeof getWhere;
+    orderBy?: IOrderBy | undefined;
+    rowWithCursorId?: any;
+    artifacts: IArtifacts;
+    dialect: IDialect;
+    firstChild?: IASTChildColumn | IASTChildComposite;
+};
+export declare type IRelation = {
+    table: string;
+    foreignKey: string;
+    referencedTable: string;
+    referencedKey: string;
+    nullable: boolean;
+};
+declare type IOneToManyOrManyToOne = "one-to-many__many-to-one";
+declare type IManyToMany = "many-to-many";
+declare type IRelationKind = "one-to-many" | "many-to-one";
+export declare type IRelationOneToManyOrManyToOne = {
+    type: IOneToManyOrManyToOne;
+    kind: IRelationKind;
+    grabMany: boolean;
+    table: string;
+    name: string;
+    relation: IRelation;
+    nullable: boolean;
+};
+export declare type IRelationManyToMany = {
+    type: IManyToMany;
+    grabMany: boolean;
+    table: string;
+    junctionTable: string;
+    name: string;
+    relations: Array<IRelation>;
+};
+export declare type IRelationField = {
+    name: string;
+    type: IOneToManyOrManyToOne;
+    kind: IRelationKind;
+    table: string;
+    grabMany: boolean;
+    relation: IRelation;
+} | {
+    name: string;
+    type: IManyToMany;
+    table: string;
+    junctionTable: string;
+    grabMany: boolean;
+    relations: Array<IRelation>;
+};
+export declare type IMappedField = {
+    name: string;
+    as: string;
+    type: string;
+    nullable: boolean;
+    table: string;
+    foreignKey: string;
+    referencedTable: string;
+    referencedKey: string;
+};
+export declare type IArtifacts = {
+    [k: string]: {
+        table: string;
+        primaryKey: string;
+        scalarFields: Array<string>;
+        relationFields: {
+            [k: string]: IRelationField;
+        };
+        mappedFields: {
+            [k: string]: IMappedField;
+        } | null;
+        dateTimeFields: {
+            [k: string]: boolean;
+        };
+        dateTimeFieldsCount: number;
+    };
+};
+export {};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@technicity/data-service-generator",
-  "version": "0.2.8",
+  "version": "0.4.1",
   "main": "./dist/index.js",
   "files": [
     "dist"

package/dist/driverOpts.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.driverOptsMSSQL = exports.driverOptsMySQL = void 0;
-const mssql = require("mssql");
-exports.driverOptsMySQL = {
-    supportBigNumbers: true,
-    typeCast: (field, next) => {
-        if (field.type == "TINY" && field.length == 1) {
-            return field.string() == "1";
-        }
-        // if (field.type === "DATE") {
-        //   return field.string();
-        // }
-        // if (
-        //   field.type === "TIMESTAMP" ||
-        //   field.type === "DATE" ||
-        //   field.type === "DATETIME"
-        // ) {
-        //   return new Date(field.string()).toISOString();
-        // }
-        if (field.type === "VAR_STRING" || field.type === "STRING") {
-            return field.string();
-        }
-        return next();
-    },
-};
-exports.driverOptsMSSQL = {
-    typeCast: (result, meta) => {
-        let typeCasts = {};
-        for (let k in meta) {
-            const v = meta[k];
-            // ids
-            if (v.identity === true || v.type === mssql.BigInt) {
-                typeCasts[v.name] = (x) => typeof x === "string" ? parseInt(x) : x;
-            }
-            // uuids
-            if (v.type === mssql.UniqueIdentifier) {
-                typeCasts[v.name] = (x) => typeof x === "string" ? x.toLocaleLowerCase() : x;
-            }
-        }
-        const data = result.recordset;
-        if (Object.keys(typeCasts).length === 0) {
-            return data;
-        }
-        return data.map((x) => {
-            for (let k of Object.keys(x)) {
-                if (typeCasts[k]) {
-                    x[k] = typeCasts[k](x[k]);
-                }
-            }
-            return x;
-        });
-    },
-};