@technicity/data-service-generator 0.13.25 → 0.14.0

package/dist/runtime/lib/getSqlAst.js

@@ -86,125 +86,137 @@ function getSqlAst(input) {
         args,
         where,
         orderBy,
-        children: children.concat(fields.map((x) => {
-            if (typeof x === "string") {
-                const mappedField = tableArtifacts.mappedFields?.[x];
-                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
-                            ]);
+        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}.${relationField.relations[0].referencedKey} = ${junctionTable}.${relationField.relations[0].foreignKey}`,
+                            //   (junctionTable: string, t: string, args: any) =>
+                            //     `${junctionTable}.${relationField.relations[1].foreignKey} = ${t}.${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}.${relationField.relations[1].foreignKey} = ${t}.${relationField.relations[1].referencedKey}`
+                            }
                         },
-                        name: x,
-                        fieldName: x,
-                        as: namespace.generate("column", x)
-                    };
+                        getWhere,
+                        artifacts,
+                        dialect
+                    });
                 }
-                // TODO - validate in dev?
-                return columnToASTChild(x, namespace);
-            }
-            const relationField = tableArtifacts.relationFields?.[x.name];
-            if (relationField == null) {
-                throw new Error("Invalid field: " + table + "." + x.name);
-            }
-            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: x.as ?? x.name,
-                    fields: x.fields,
-                    args: x.args,
+                    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}.${relationField.relations[0].referencedKey} = ${junctionTable}.${relationField.relations[0].foreignKey}`,
-                        //   (junctionTable: string, t: string, args: any) =>
-                        //     `${junctionTable}.${relationField.relations[1].foreignKey} = ${t}.${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}.${relationField.relations[1].foreignKey} = ${t}.${relationField.relations[1].referencedKey}`
-                        }
+                    // 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
                 });
             }
-            return getSqlAst({
-                table: relationField.table,
-                fieldName: x.as ?? x.name,
-                fields: x.fields,
-                args: x.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
-            });
+            else {
+                return columnToASTChild(k, namespace);
+            }
         }))
     };
 }

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

@@ -1,5 +1,4 @@
-import type { IGetSQLASTInput, IArtifacts, IDialect, TDbCall, TFormatQuery, TBeginTransaction, TContext } from "../IRuntime";
-import type { TMiddleware, TResolveParams } from "../IRuntime";
+import type { IGetSQLASTInput, IArtifacts, IDialect, TDbCall, TFormatQuery, TBeginTransaction, TContext, TMiddleware, 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> {

package/dist/runtime/lib/shared.js

@@ -42,7 +42,6 @@ const getSqlAst_1 = require("./getSqlAst");
 const getWhere_1 = require("./getWhere");
 const getDateTimeStringMySQL_1 = require("./getDateTimeStringMySQL");
 const cursor_1 = require("./cursor");
-const runTransforms_1 = require("./runTransforms");
 const addNullFallbacks_1 = require("./addNullFallbacks");
 const SDKNotFoundError_1 = require("./SDKNotFoundError");
 const SDKBadWhereError_1 = require("./SDKBadWhereError");
@@ -160,7 +159,11 @@ async function getData(input, dbCall, formatQuery, dialect) {
     }
     // we need to read the query AST and build a new "SQL AST" from which the SQL and
     // const sqlAST = queryAST.queryASTToSqlAST(resolveInfo, options, context);
-    const fields = input.fields ?? getScalarFields(input.resource, input.artifacts);
+    const fields = input.fields ??
+        getScalarFields(input.resource, input.artifacts).reduce((acc, x) => {
+            acc[x] = true;
+            return acc;
+        }, {});
     const orderByListPaginatedRootResult = 
     // MSSQL's OFFSET and FETCH requires ORDER BY, so we need to provide a fallback
     dialect === "mssql" && paginationType === "limit-offset"
@@ -267,7 +270,7 @@ async function getData(input, dbCall, formatQuery, dialect) {
                 fieldName: "data",
                 args: argsTotalCount,
                 // Because we're going to manually set children anyway
-                fields: [],
+                fields: {},
                 getWhere: getWhere_1.getWhere,
                 // We don't want the where clause to include cursor-related stuff
                 rowWithMatchingCursor: null,
@@ -340,21 +343,23 @@ async function getCached(input, dbCall, formatQuery, dialect, cache) {
 function ensureUuidSelect(input) {
     const { resource, artifacts } = input;
     const remove = [];
-    ensure(resource, input);
+    ensure(resource, input.fields);
     function ensure(type, input, path = []) {
         const { scalarFields, relationFields } = artifacts[type];
         if (!scalarFields.includes("uuid"))
             return;
-        const fields = input.fields || [];
-        if (!fields.includes("uuid")) {
+        const fields = input || {};
+        if (!Object.keys(fields).includes("uuid")) {
             remove.push(path);
-            fields.unshift("uuid");
+            fields["uuid"] = true;
         }
-        for (const field of fields)
-            if (typeof field == "object") {
-                const { name } = field;
-                const { table } = relationFields[name];
-                ensure(table, field, path.concat(name));
+        const entries = Object.entries(fields);
+        for (const [k, v] of entries)
+            if (typeof v === "object") {
+                const table = relationFields[k]?.table;
+                if (table != null) {
+                    ensure(table, v.$fields, path.concat(k));
+                }
             }
     }
     return remove;
@@ -832,27 +837,17 @@ async function mapMappedFields(artifactsForTable, data, dbCall, formatQuery) {
     }
 }
 // 1. Remove additional keys added to data for batches and joins
-// 2. Execute `transform` functions if they exist
 function postProcess(data, fields, shouldRemoveExtraKeys) {
     if (shouldRemoveExtraKeys) {
         removeExtraKeys(data, fields);
     }
-    (0, runTransforms_1.runTransforms)(data, fields);
 }
 exports.postProcess = postProcess;
 function removeExtraKeys(data, fields) {
     if (data == null || (Array.isArray(data) && data[0] == null)) {
         return;
     }
-    let fieldKeys = [];
-    for (let x of fields) {
-        if (typeof x === "string") {
-            fieldKeys.push(x);
-        }
-        else {
-            fieldKeys.push(x.as ?? x.name);
-        }
-    }
+    let fieldKeys = Object.keys(fields);
     const dataKeys = Array.isArray(data) ? Object.keys(data[0]) : Object.keys(data);
     const extraDataKeys = _.difference(dataKeys, fieldKeys);
     for (let k of extraDataKeys) {
@@ -865,16 +860,16 @@ function removeExtraKeys(data, fields) {
             delete data[k];
         }
     }
-    for (let x of fields) {
-        if (typeof x === "object") {
-            const k = x.as ?? x.name;
+    const entries = Object.entries(fields);
+    for (let [k, v] of entries) {
+        if (typeof v === "object" && v.$fields != null) {
             if (Array.isArray(data)) {
                 for (let d of data) {
-                    removeExtraKeys(d[k], x.fields);
+                    removeExtraKeys(d[k], v.$fields);
                 }
             }
             else {
-                removeExtraKeys(data[k], x.fields);
+                removeExtraKeys(data[k], v.$fields);
             }
         }
     }
@@ -902,11 +897,9 @@ function typeCastSqlite(data, fields, table, artifacts) {
         throw new Error(`Failed to resolve typeCastMap for table \`${table}\``);
     }
     if (booleanColumns.size > 0) {
-        for (let field of fields) {
-            const name = typeof field === "string" ? field : field.name;
-            const as = typeof field === "string" ? undefined : field.as;
-            if (booleanColumns.has(name)) {
-                const k = as ?? name;
+        const keys = Object.keys(fields);
+        for (let k of keys) {
+            if (booleanColumns.has(k)) {
                 if (Array.isArray(data)) {
                     for (let d of data) {
                         d[k] = !!d[k];
@@ -919,21 +912,25 @@ function typeCastSqlite(data, fields, table, artifacts) {
         }
     }
     const tableArtifacts = artifacts[table];
-    for (let x of fields) {
-        if (typeof x === "object") {
-            const name = x.name;
-            const relationFields = tableArtifacts.relationFields[name];
+    const entries = Object.entries(fields);
+    for (let [k, v] of entries) {
+        if (typeof v === "object") {
+            const relationFields = tableArtifacts.relationFields[k];
             if (relationFields == null) {
-                throw new Error(`Failed to resolve relationFields for field \`${name}\``);
+                throw new Error(`Failed to resolve relationFields for field \`${k}\``);
             }
-            const k = x.as ?? name;
+            const fields = v.$fields ??
+                tableArtifacts.scalarFields.reduce((acc, x) => {
+                    acc[x] = true;
+                    return acc;
+                }, {});
             if (Array.isArray(data)) {
                 for (let d of data) {
-                    typeCastSqlite(d[k], x.fields, relationFields.table, artifacts);
+                    typeCastSqlite(d[k], fields, relationFields.table, artifacts);
                 }
             }
             else {
-                typeCastSqlite(data[k], x.fields, relationFields.table, artifacts);
+                typeCastSqlite(data[k], fields, relationFields.table, artifacts);
             }
         }
     }

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.js

@@ -9,64 +9,48 @@ const _1 = require(".");
 const addWhereValidTrue_1 = require("../test/addWhereValidTrue");
 (0, globals_1.describe)("traverseFieldArgs", () => {
     (0, globals_1.test)("should work", () => {
-        const fields = [
-            "id",
-            "uuid",
-            {
-                name: "business",
-                fields: ["id", "uuid", "name"]
+        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" }
             },
-            {
-                name: "sessionList",
-                fields: ["id", "archived", { name: "fooList", fields: ["id", "uuid"] }],
-                args: {
-                    $where: { archived: false },
-                    $orderBy: { id: "desc" }
-                }
-            },
-            {
-                name: "usrList",
-                fields: ["firstName", "lastName", "password"],
-                args: {
-                    $where: { valid: false, 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",
-            "uuid",
-            {
-                name: "business",
-                fields: ["id", "uuid", "name"],
-                args: { $where: { valid: true } }
+        strict_1.default.deepEqual(fields, {
+            id: true,
+            uuid: true,
+            business: {
+                $fields: { id: true, uuid: true, name: true },
+                $where: { valid: true }
             },
-            {
-                name: "sessionList",
-                fields: [
-                    "id",
-                    "archived",
-                    {
-                        name: "fooList",
-                        fields: ["id", "uuid"],
-                        args: { $where: { valid: true } }
-                    }
-                ],
-                args: {
-                    $where: { valid: true, archived: false },
-                    $orderBy: { id: "desc" }
-                }
+            sessionList: {
+                $fields: {
+                    id: true,
+                    archived: true,
+                    fooList: { $fields: { id: true, uuid: true }, $where: { valid: true } }
+                },
+                $where: { valid: true, archived: false },
+                $orderBy: { id: "desc" }
             },
-            {
-                name: "usrList",
-                fields: ["firstName", "lastName", "password"],
-                args: {
-                    // Should not be overwritten
-                    $where: { valid: false, 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.13.25",
+  "version": "0.14.0",
   "main": "./dist/index.js",
   "files": [
     "dist"
@@ -13,6 +13,7 @@
     "test:unit": "jest ./src"
   },
   "dependencies": {
+    "@types/better-sqlite3": "^7.6.3",
     "better-sqlite3": "^8.1.0",
     "bluebird": "^3.7.2",
     "change-case": "^4.1.1",
@@ -36,7 +37,6 @@
     "@jest/globals": "^29.4.3",
     "@swc/core": "^1.3.36",
     "@swc/jest": "^0.2.24",
-    "@types/better-sqlite3": "^7.6.3",
     "@types/fs-extra": "9.0.13",
     "@types/lodash": "4.14.177",
     "@types/mssql": "^6.0.7",

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 {};