@technicity/data-service-generator 0.4.4 → 0.5.0

package/dist/runtime/{__shared.js → lib/shared.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._prepareWhere = exports.whereNeedsProcessing = exports.deleteList = exports.del = exports.patchList = exports.patch = exports.post = exports.resolve = void 0;
+exports._prepareWhere = exports.whereNeedsProcessing = exports.MiddlewareHandler = exports.resolve = void 0;
 // @ts-ignore
 // import * as queryAST from "join-monster/dist/query-ast-to-sql-ast";
 // @ts-ignore
@@ -9,22 +9,87 @@ exports._prepareWhere = exports.whereNeedsProcessing = exports.deleteList = expo
 const batch_planner_1 = require("join-monster/dist/batch-planner");
 // @ts-ignore
 const util_1 = require("join-monster/dist/util");
+const async_hooks_1 = require("async_hooks");
 const _ = require("lodash/fp");
-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 stringifyWhere_1 = require("../stringifyWhere");
-const getOrderBy_1 = require("../getOrderBy");
-async function resolve(input, dbCall, formatQuery, options) {
+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 stringifyWhere_1 = require("./stringifyWhere");
+const getOrderBy_1 = require("./getOrderBy");
+async function resolve(input, dbCall, formatQuery, dialect, middlewareHandler) {
+    // https://github.com/prisma/prisma/blob/822198e5ba21535364d20c86901b8c3778ebf6a3/packages/client/src/runtime/getPrismaClient.ts#L1087
+    let index = -1;
+    if (middlewareHandler.length() > 0) {
+        const resource = new async_hooks_1.AsyncResource("sdk-request");
+        const params = input;
+        const consumer = (paramsMaybeMutated) => {
+            const nextMiddleware = middlewareHandler.get(++index);
+            if (nextMiddleware != null) {
+                return nextMiddleware(paramsMaybeMutated, consumer);
+            }
+            const paramsChanged = { ...input, ...params };
+            return _resolve(paramsChanged, dbCall, formatQuery, dialect);
+        };
+        return resource.runInAsyncScope(() => consumer(params));
+    }
+    return _resolve(input, dbCall, formatQuery, dialect);
+}
+exports.resolve = resolve;
+function _resolve(input, dbCall, formatQuery, dialect) {
+    if (input.action === "findUnique") {
+        return getData(input, dbCall, formatQuery, dialect);
+    }
+    if (input.action === "findMany") {
+        return getData(input, dbCall, formatQuery, dialect);
+    }
+    if (input.action === "findManyPaginated") {
+        return getData(input, dbCall, formatQuery, dialect);
+    }
+    if (input.action === "create") {
+        return create(input, dbCall, formatQuery, dialect);
+    }
+    if (input.action === "update") {
+        return update(input, dbCall, formatQuery, dialect);
+    }
+    if (input.action === "updateMany") {
+        return updateMany(input, dbCall, formatQuery, dialect);
+    }
+    if (input.action === "delete") {
+        return del(input, dbCall, formatQuery, dialect);
+    }
+    if (input.action === "deleteMany") {
+        return deleteMany(input, dbCall, formatQuery, dialect);
+    }
+    throw new Error("Invalid action: " + input.action);
+}
+class MiddlewareHandler {
+    constructor() {
+        this._middlewares = [];
+    }
+    register(middleware) {
+        this._middlewares.push(middleware);
+    }
+    get(id) {
+        return this._middlewares[id];
+    }
+    has(id) {
+        return !!this._middlewares[id];
+    }
+    length() {
+        return this._middlewares.length;
+    }
+}
+exports.MiddlewareHandler = MiddlewareHandler;
+async function getData(input, dbCall, formatQuery, dialect) {
     const context = {};
-    const kind = input.kind;
-    const primaryKey = input.artifacts[input.table].primaryKey;
+    const action = input.action;
+    const primaryKey = input.artifacts[input.resource].primaryKey;
     let rowWithMatchingCursor = undefined;
-    if (kind === "listPaginated") {
+    if (action === "findManyPaginated") {
         if (input.args?.$paginate == null) {
             throw new Error("$paginate required but not supplied");
         }
@@ -34,7 +99,7 @@ async function resolve(input, dbCall, formatQuery, options) {
                 ? input.args.$paginate.after
                 : input.args.$paginate.before;
             rowWithMatchingCursor = await dbCall(formatQuery("SELECT * FROM ?? WHERE ?? = ?", [
-                input.table,
+                input.resource,
                 primaryKey,
                 cursor_1.decodeCursor(cursor),
             ])).then((xs) => xs[0]);
@@ -42,25 +107,35 @@ async function resolve(input, dbCall, formatQuery, options) {
     }
     // 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.table, input.artifacts);
-    const orderByListPaginatedRootResult = kind === "listPaginated" ? getOrderBy_1.getOrderBy(input.args, primaryKey) : undefined;
+    const fields = input.fields ?? getScalarFields(input.resource, input.artifacts);
+    const orderByListPaginatedRootResult = action === "findManyPaginated"
+        ? getOrderBy_1.getOrderBy(input.args, primaryKey)
+        : undefined;
+    const grabMany = action === "findMany" ||
+        action === "findManyPaginated" ||
+        action === "updateMany" ||
+        action === "deleteMany";
     const sqlAST = getSqlAst_1.getSqlAst({
         ...input,
+        table: input.resource,
+        fieldName: "data",
         fields,
         getWhere: getWhere_1.getWhere,
         orderBy: orderByListPaginatedRootResult?.orderBy,
         rowWithMatchingCursor,
-        dialect: options.dialect,
+        dialect,
+        grabMany,
     });
+    const options = { dialect };
     let { sql, shapeDefinition } = await util_1.compileSqlAST(sqlAST, context, options);
     if (!sql) {
         // return {};
         throw new Error("No SQL");
     }
     // TODO - remove if limit support added for mysql dialect
-    if (kind === "list" || kind === "listPaginated") {
+    if (action === "findMany" || action === "findManyPaginated") {
         let limit = undefined;
-        if (kind === "listPaginated") {
+        if (action === "findManyPaginated") {
             limit = (typeof input?.args?.$paginate?.first === "number"
                 ? input?.args?.$paginate?.first
                 : input?.args?.$paginate?.last);
@@ -71,7 +146,7 @@ async function resolve(input, dbCall, formatQuery, options) {
             limit = input?.args?.$limit;
         }
         if (typeof limit === "number") {
-            if (options.dialect === "mysql") {
+            if (dialect === "mysql") {
                 sql += ` LIMIT ${limit}`;
             }
             else {
@@ -91,7 +166,7 @@ async function resolve(input, dbCall, formatQuery, options) {
     // We only need to remove extra keys if input.fields isn't
     // specified, since otherwise there wouldn't be extra keys
     const shouldRemoveExtraKeys = input.fields != null;
-    if (kind !== "listPaginated") {
+    if (action !== "findManyPaginated") {
         // Remove additional keys that are added for batches and joins
         // Do later for `listPaginated`, since the `id` is needed for
         // creating the cursor
@@ -112,27 +187,48 @@ async function resolve(input, dbCall, formatQuery, options) {
         //   }
         //   return true;
         // });
-        if (kind === "listPaginated") {
+        if (action === "findManyPaginated") {
+            const argsTotalCount = input.args && _.cloneDeep(input.args);
+            if (argsTotalCount != null) {
+                if (argsTotalCount.$paginate != null) {
+                    // We don't want the where clause to include cursor-related stuff
+                    delete argsTotalCount.$paginate.after;
+                    delete argsTotalCount.$paginate.before;
+                }
+            }
+            const sqlASTTotalCount = getSqlAst_1.getSqlAst({
+                ...input,
+                table: input.resource,
+                fieldName: "data",
+                args: argsTotalCount,
+                // Because we're going to manually set children anyway
+                fields: [],
+                getWhere: getWhere_1.getWhere,
+                // We don't want the where clause to include cursor-related stuff
+                rowWithMatchingCursor: null,
+                dialect,
+                grabMany: true,
+            });
+            // Because orderBy doesn't matter for total count.
+            // getOrderBy adds an element if paginating, so deleting args.$orderBy
+            // isn't sufficient.
+            delete sqlASTTotalCount.orderBy;
             data = await wrapListPaginated(data, input.args, orderByListPaginatedRootResult.flip, (xs) => {
                 postProcess(xs, fields, shouldRemoveExtraKeys);
-            }, sqlAST, dbCall, input.artifacts[input.table].primaryKey, context, options);
+            }, sqlASTTotalCount, dbCall, input.artifacts[input.resource].primaryKey, context, options);
         }
         return data;
     }
-    if (data == null && kind == null) {
+    if (data == null && !grabMany) {
         throw new SDKNotFoundError_1.SDKNotFoundError();
     }
     return data;
 }
-exports.resolve = resolve;
 // Not recursive at the moment; only supported at the root.
 // TODO - remove if support for pagination for mysql dialect
 // is added (I doubt it)
-async function wrapListPaginated(data, args, flip, cb, sqlAST, dbCall, primaryKey, context, options) {
-    const isPaginatingBackward = args.$paginate.last != null;
-    const limit = isPaginatingBackward
-        ? args.$paginate.last
-        : args.$paginate.first;
+async function wrapListPaginated(data, args, flip, cb, sqlASTTotalCount, dbCall, primaryKey, context, options) {
+    const limit = flip ? args.$paginate.last : args.$paginate.first;
     const hasMoreResults = data.length === limit + 1;
     if (hasMoreResults) {
         // because we peeked
@@ -141,15 +237,14 @@ async function wrapListPaginated(data, args, flip, cb, sqlAST, dbCall, primaryKe
     if (flip) {
         data = data.reverse();
     }
-    const hasPreviousPage = isPaginatingBackward ? hasMoreResults : false;
-    const hasNextPage = isPaginatingBackward ? false : hasMoreResults;
+    const hasPreviousPage = flip ? hasMoreResults : false;
+    const hasNextPage = flip ? false : hasMoreResults;
     const startKey = data?.[0]?.[primaryKey];
     const endKey = data?.[data.length - 1]?.[primaryKey];
     const startCursor = startKey == null ? null : cursor_1.encodeCursor(startKey);
     const endCursor = endKey == null ? null : cursor_1.encodeCursor(endKey);
     // Replace field selection with `COUNT(*)`
     const fieldNameTotalCount = "totalCount";
-    const sqlASTTotalCount = { ...sqlAST };
     sqlASTTotalCount.children = [
         {
             type: "expression",
@@ -158,9 +253,6 @@ async function wrapListPaginated(data, args, flip, cb, sqlAST, dbCall, primaryKe
             as: fieldNameTotalCount,
         },
     ];
-    // Remove ORDER BY to avoid the error:
-    // Column "X" is invalid in the ORDER BY clause because it is not contained in either an aggregate function or the GROUP BY clause.
-    delete sqlASTTotalCount.orderBy;
     const { sql: sqlTotalCount } = await util_1.compileSqlAST(sqlASTTotalCount, context, options);
     const totalCount = await dbCall(sqlTotalCount).then((xs) => xs[0][fieldNameTotalCount]);
     cb(data);
@@ -175,16 +267,15 @@ async function wrapListPaginated(data, args, flip, cb, sqlAST, dbCall, primaryKe
         results: data,
     };
 }
-async function post(input) {
-    async function _post() {
-        const { dbCall, formatQuery } = input;
+async function create(input, dbCall, formatQuery, dialect) {
+    async function _create() {
         // Shallow clone, as we're going to mutate later
         const data = { ...input.data };
-        const tableArtifacts = input.artifacts[input.table];
-        if (hasMappedFields(input.artifacts, input.table, data)) {
+        const tableArtifacts = input.artifacts[input.resource];
+        if (hasMappedFields(input.artifacts, input.resource, data)) {
             await mapMappedFields(tableArtifacts, data, dbCall, formatQuery);
         }
-        if (input.dialect === "mysql" && tableArtifacts.dateTimeFieldsCount > 0) {
+        if (dialect === "mysql" && tableArtifacts.dateTimeFieldsCount > 0) {
             for (let k in tableArtifacts.dateTimeFields) {
                 if (data[k] != null) {
                     data[k] = getDateTimeStringMySQL_1.getDateTimeStringMySQL(data[k]);
@@ -197,8 +288,8 @@ async function post(input) {
                 delete data[k];
             }
         }
-        if (input.dialect === "mysql") {
-            const inserted = await dbCall(formatQuery("INSERT INTO ?? SET ?", [input.table, data]));
+        if (dialect === "mysql") {
+            const inserted = await dbCall(formatQuery("INSERT INTO ?? SET ?", [input.resource, data]));
             return inserted.insertId;
         }
         else {
@@ -208,39 +299,31 @@ async function post(input) {
                 .map(() => "??")
                 .join(",")}) VALUES (${values
                 .map(() => "?")
-                .join(",")}) SELECT SCOPE_IDENTITY() AS [SCOPE_IDENTITY]`, [input.table, ...columns, ...values]));
+                .join(",")}) SELECT SCOPE_IDENTITY() AS [SCOPE_IDENTITY]`, [input.resource, ...columns, ...values]));
             return inserted[0]["SCOPE_IDENTITY"];
         }
     }
-    const id = await _post();
-    return resolve({
-        table: input.table,
-        fieldName: input.fieldName,
-        args: { $where: { id } },
-        fields: input.fields,
-        grabMany: false,
-        artifacts: input.artifacts,
-    }, input.dbCall, input.formatQuery, { dialect: input.dialect });
+    const id = await _create();
+    return getData({ ...input, args: { $where: { id } } }, dbCall, formatQuery, dialect);
 }
-exports.post = post;
-async function patch(input) {
-    async function _patch() {
-        const { dbCall, formatQuery } = input;
-        const tableArtifacts = input.artifacts[input.table];
-        const where = getWhere_1.getWhere(input.table, input.args, input.dialect);
+async function update(input, dbCall, formatQuery, dialect) {
+    async function _update() {
+        const escapeId = stringifyWhere_1.getEscapeId(dialect);
+        const tableArtifacts = input.artifacts[input.resource];
+        const where = getWhere_1.getWhere(escapeId(input.resource), input.args, dialect);
         if (where == null) {
             throw new Error("Null where");
         }
-        const current = await dbCall(formatQuery("SELECT * FROM ?? WHERE " + where, [input.table])).then((xs) => xs[0]);
+        const current = await dbCall(formatQuery("SELECT * FROM ?? WHERE " + where, [input.resource])).then((xs) => xs[0]);
         if (current == null) {
             throw new SDKNotFoundError_1.SDKNotFoundError();
         }
         // Shallow clone, as we're going to mutate later
         const data = { ...input.data };
-        if (hasMappedFields(input.artifacts, input.table, data)) {
+        if (hasMappedFields(input.artifacts, input.resource, data)) {
             await mapMappedFields(tableArtifacts, data, dbCall, formatQuery);
         }
-        if (input.dialect === "mysql" && tableArtifacts.dateTimeFieldsCount > 0) {
+        if (dialect === "mysql" && tableArtifacts.dateTimeFieldsCount > 0) {
             for (let k in tableArtifacts.dateTimeFields) {
                 if (data[k] != null) {
                     data[k] = getDateTimeStringMySQL_1.getDateTimeStringMySQL(data[k]);
@@ -257,20 +340,12 @@ async function patch(input) {
         if (Object.keys(data).length === 0) {
             return true;
         }
-        await dbCall(getUpdateQuery(input.table, data, where, input.dialect, input.formatQuery));
+        await dbCall(getUpdateQuery(input.resource, data, where, dialect, formatQuery));
         return true;
     }
-    await _patch();
-    return resolve({
-        table: input.table,
-        fieldName: input.fieldName,
-        args: input.args,
-        fields: input.fields,
-        grabMany: false,
-        artifacts: input.artifacts,
-    }, input.dbCall, input.formatQuery, { dialect: input.dialect });
+    await _update();
+    return getData(input, dbCall, formatQuery, dialect);
 }
-exports.patch = patch;
 function getUpdateQuery(table, data, where, dialect, formatQuery) {
     // Assumes `data` is not empty
     const escapeId = stringifyWhere_1.getEscapeId(dialect);
@@ -320,20 +395,20 @@ function getUpdateQuery(table, data, where, dialect, formatQuery) {
     q += ` WHERE ${where}`;
     return formatQuery(q, values);
 }
-async function patchList(input) {
-    async function _patchList() {
-        const { dbCall, formatQuery } = input;
-        const tableArtifacts = input.artifacts[input.table];
-        const where = getWhere_1.getWhere(input.table, input.args, input.dialect);
+async function updateMany(input, dbCall, formatQuery, dialect) {
+    async function _updateMany() {
+        const escapeId = stringifyWhere_1.getEscapeId(dialect);
+        const tableArtifacts = input.artifacts[input.resource];
+        const where = getWhere_1.getWhere(escapeId(input.resource), input.args, dialect);
         if (where == null) {
             throw new Error("Null where");
         }
         // Shallow clone, as we're going to mutate later
         const data = { ...input.data };
-        if (hasMappedFields(input.artifacts, input.table, data)) {
+        if (hasMappedFields(input.artifacts, input.resource, data)) {
             await mapMappedFields(tableArtifacts, data, dbCall, formatQuery);
         }
-        if (input.dialect === "mysql" && tableArtifacts.dateTimeFieldsCount > 0) {
+        if (dialect === "mysql" && tableArtifacts.dateTimeFieldsCount > 0) {
             for (let k in tableArtifacts.dateTimeFields) {
                 if (data[k] != null) {
                     data[k] = getDateTimeStringMySQL_1.getDateTimeStringMySQL(data[k]);
@@ -350,27 +425,17 @@ async function patchList(input) {
         if (Object.keys(data).length === 0) {
             return [];
         }
-        await dbCall(getUpdateQuery(input.table, data, where, input.dialect, input.formatQuery));
+        await dbCall(getUpdateQuery(input.resource, data, where, dialect, formatQuery));
         return true;
     }
-    await _patchList();
-    return resolve({
-        table: input.table,
-        fieldName: input.fieldName,
-        args: input.args,
-        fields: input.fields,
-        artifacts: input.artifacts,
-        grabMany: true,
-        kind: "list",
-    }, input.dbCall, input.formatQuery, { dialect: input.dialect });
+    await _updateMany();
+    return getData(input, dbCall, formatQuery, dialect);
 }
-exports.patchList = patchList;
-async function del(input) {
-    const { dbCall, formatQuery } = input;
+async function del(input, dbCall, formatQuery, dialect) {
     const _findOne = Object.entries(input.args.$where)[0];
     const findOne = { key: _findOne[0], value: _findOne[1] };
     const current = await dbCall(formatQuery("SELECT * FROM ?? WHERE ?? = ?", [
-        input.table,
+        input.resource,
         findOne.key,
         findOne.value,
     ])).then((xs) => xs[0]);
@@ -378,25 +443,23 @@ async function del(input) {
         throw new SDKNotFoundError_1.SDKNotFoundError();
     }
     await dbCall(formatQuery("DELETE FROM ?? WHERE ?? = ?", [
-        input.table,
+        input.resource,
         findOne.key,
         findOne.value,
     ]));
     return true;
 }
-exports.del = del;
-async function deleteList(input) {
-    const { dbCall, formatQuery } = input;
-    const where = getWhere_1.getWhere(input.table, input.args, input.dialect);
+async function deleteMany(input, dbCall, formatQuery, dialect) {
+    const escapeId = stringifyWhere_1.getEscapeId(dialect);
+    const where = getWhere_1.getWhere(escapeId(input.resource), input.args, dialect);
     if (where == null) {
         throw new Error("Null where");
     }
     const sql = "DELETE FROM ?? WHERE " + where;
-    const values = [input.table];
+    const values = [input.resource];
     await dbCall(formatQuery(sql, values));
     return true;
 }
-exports.deleteList = deleteList;
 function getScalarFields(table, artifacts) {
     return artifacts[table].scalarFields;
 }

package/dist/{stringifyWhere.d.ts → runtime/lib/stringifyWhere.d.ts}

@@ -1,4 +1,4 @@
-import type { IOrderBy, IDialect } from "./types";
+import type { IOrderBy, IDialect } from "../IRuntime";
 declare type IWhere = {
     [k: string]: any;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@technicity/data-service-generator",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "main": "./dist/index.js",
   "files": [
     "dist"
@@ -34,6 +34,7 @@
     "@types/sqlstring": "^2.2.1",
     "env-cmd": "^10.1.0",
     "mocha": "9.0.3",
+    "sinon": "^11.1.2",
     "typescript": "^4.0.5"
   }
 }

package/dist/runtime/__shared.d.ts

@@ -1,32 +0,0 @@
-import type { IArtifacts, IDialect, TDbCall, TFormatQuery } from "../types";
-import { TResolveInput, TPatchInput, TPatchListInput, TPostInput, TDelInput, TDeleteListInput } from "./IRuntime";
-export declare function resolve(input: TResolveInput, dbCall: TDbCall, formatQuery: TFormatQuery, options: {
-    dialect: IDialect;
-}): Promise<any>;
-export declare function post(input: TPostInput & {
-    dialect: IDialect;
-    dbCall: TDbCall;
-    formatQuery: TFormatQuery;
-}): Promise<any>;
-export declare function patch(input: TPatchInput & {
-    dialect: IDialect;
-    dbCall: TDbCall;
-    formatQuery: TFormatQuery;
-}): Promise<any>;
-export declare function patchList(input: TPatchListInput & {
-    dialect: IDialect;
-    dbCall: TDbCall;
-    formatQuery: TFormatQuery;
-}): Promise<any>;
-export declare function del(input: TDelInput & {
-    dialect: IDialect;
-    dbCall: TDbCall;
-    formatQuery: TFormatQuery;
-}): Promise<boolean>;
-export declare function deleteList(input: TDeleteListInput & {
-    dialect: IDialect;
-    dbCall: TDbCall;
-    formatQuery: TFormatQuery;
-}): Promise<boolean>;
-export declare function whereNeedsProcessing(where: any): boolean;
-export declare function _prepareWhere(artifacts: IArtifacts, table: string, data: any, dbCall: TDbCall, formatQuery: TFormatQuery): Promise<{}>;

package/dist/types.d.ts

@@ -1,142 +0,0 @@
-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;
-    rowWithMatchingCursor?: 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

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