@technicity/data-service-generator 0.4.7 → 0.5.0

package/dist/{generate.d.ts → generation/generate.d.ts}

@@ -1,4 +1,4 @@
-import type { IDialect, ISupplementClientOpts } from "./types";
+import type { IDialect, ISupplementClientOpts } from "../runtime/IRuntime";
 declare type ISpecialCaseUuidColumn = boolean;
 declare type IIncludeMappedFields = boolean;
 declare type IGenerateInput = {

package/dist/{generate.js → generation/generate.js}

@@ -13,9 +13,9 @@ const mssql = require("mssql");
 // @ts-ignore
 const TSqlString = require("tsqlstring");
 const json_schema_to_typescript_1 = require("json-schema-to-typescript");
-const getDuplicates_1 = require("./getDuplicates");
-const isNotNullOrUndefined_1 = require("./isNotNullOrUndefined");
-const mysql = require("./mysql");
+const getDuplicates_1 = require("../lib/getDuplicates");
+const isNotNullOrUndefined_1 = require("../lib/isNotNullOrUndefined");
+const mysql = require("../mysql");
 // json-schema-to-typescript inlines everything. We don't want that,
 // so use `tsType`, and add imports manually.
 // https://github.com/bcherny/json-schema-to-typescript#custom-schema-properties
@@ -23,6 +23,9 @@ const mysql = require("./mysql");
 // Meh
 let query = undefined;
 let dialect = "mysql";
+const json2TsOpts = {
+    bannerComment: "",
+};
 async function generate(input) {
     if (input.tables != null && input.excludeTables != null) {
         throw new Error("Must specify either `tables` or `excludeTables`, not both");
@@ -59,6 +62,7 @@ async function generate(input) {
     const sdkSource = await getSDKSource(data, specialCaseUuidColumn, supplementClientOpts);
     const sdkFilename = "index.ts";
     const artifactsFilename = "artifacts.ts";
+    const IRuntimeFilename = "IRuntime.d.ts";
     const tsConfigJSON = {
         compilerOptions: {
             module: "commonjs",
@@ -67,25 +71,27 @@ async function generate(input) {
             declaration: true,
             outDir: "./sdk-ts",
         },
-        include: [sdkFilename, artifactsFilename],
+        include: [sdkFilename, artifactsFilename, IRuntimeFilename],
     };
     const packageJSON = {
         name: "temp",
         version: "1.0.0",
         // Deps need to be included so that they're inlined by ncc
         dependencies: {
-            ...require("../package.json").dependencies,
+            ...require("../../package.json").dependencies,
             uuid: "8.3.2",
         },
         devDependencies: {
-            "@types/node": require("../package.json").devDependencies["@types/node"],
-            typescript: require("../package.json").devDependencies.typescript,
+            "@types/node": require("../../package.json").devDependencies["@types/node"],
+            typescript: require("../../package.json").devDependencies.typescript,
         },
     };
     const tmpDirPath = path.join(os.tmpdir(), `dsg-${Date.now()}`);
     fse.mkdirpSync(tmpDirPath);
     fs.writeFileSync(path.join(tmpDirPath, sdkFilename), sdkSource);
     fs.writeFileSync(path.join(tmpDirPath, artifactsFilename), artifactsSource);
+    const sourceIRuntimeFilePath = path.join(__dirname, "../runtime", IRuntimeFilename);
+    fse.copyFileSync(sourceIRuntimeFilePath, path.join(tmpDirPath, IRuntimeFilename));
     const typesDirPath = path.join(tmpDirPath, "types");
     fse.mkdirpSync(typesDirPath);
     fs.writeFileSync(path.join(typesDirPath, "_shared.ts"), getTypeShared());
@@ -115,7 +121,14 @@ async function generate(input) {
     child_process.execSync("npm i", { cwd: tmpDirPath, stdio: "inherit" });
     child_process.execSync(`npx -p @vercel/ncc@${nccVersion} ncc build ./${sdkFilename} -o ${tmpBuildOutputPath} -e ./artifacts`, { cwd: tmpDirPath, stdio: "inherit" });
     // TODO: workaround for artifacts.js not being output by ncc
-    fs.writeFileSync(path.join(tmpBuildOutputPath, "artifacts.js"), artifactsSource.replace("export const artifacts = ", "module.exports.artifacts = "));
+    fs.writeFileSync(path.join(tmpBuildOutputPath, "artifacts.js"), artifactsSource
+        .replace("export const artifacts: IArtifacts = ", "module.exports.artifacts = ")
+        .split("\n")
+        // Remove import
+        .slice(2)
+        .join("\n"));
+    // TODO: workaround for IRuntime.d.ts not being included
+    fse.copyFileSync(sourceIRuntimeFilePath, path.join(tmpBuildOutputPath, IRuntimeFilename));
     if (!fs.existsSync(outdir)) {
         fse.mkdirpSync(outdir);
     }
@@ -158,8 +171,8 @@ function init(input) {
 // It's a bit awkward to put __whereNeedsProcessing, __prepareWhere on the class,
 // but it allows us to share the same database pool, clientOpts, etc.
 async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts) {
-    // TODO: runtime: IRuntime
     const src = `import { v4 as uuidv4 } from "uuid";
+  import type { IRuntime, TMiddleware, TContext } from "./IRuntime"
   import { artifacts } from "./artifacts";
   import type { Paginate, ListPaginated } from "./types/_shared";
   ${input.reduce((acc, x) => {
@@ -181,7 +194,7 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
     }, "")}
 
   export class SDK {
-    runtime: any;
+    runtime: IRuntime;
   
     constructor(opts: {
       runtime: any;
@@ -194,15 +207,19 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
         : "opts.otherOpts"}, artifacts);
     }
 
-    __whereNeedsProcessing(where: any) {
-      return this.runtime.whereNeedsProcessing(where);
+    $use(middleware: TMiddleware) {
+      return this.runtime.$use(middleware);
     }
 
-    async __prepareWhere(
+    $whereNeedsProcessing(where: any) {
+      return this.runtime.$whereNeedsProcessing(where);
+    }
+
+    async $prepareWhere(
       table: string,
       where: any
     ) {
-      return this.runtime._prepareWhere(artifacts, table, where);
+      return this.runtime.$prepareWhere(artifacts, table, where);
     }
 
     ${(await Promise.all(input.flatMap(async (x) => {
@@ -221,16 +238,16 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
                 param1: ${findOnes
                 .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
                 .join(" | ")}, 
-                param2?: { fields?: ${x.typeFieldsName}, correlationId?: string }
+                param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
               ): Promise<${x.typeReturnBaseName}> {
               return this.runtime.resolve(
                 {
-                  table: "${x.table}",
-                  fieldName: "${x.fieldName}",
+                  resource: "${x.table}",
+                  action: "findUnique",
                   args: { $where: param1 },
                   fields: param2?.fields,
-                  grabMany: false,
-                  artifacts
+                  artifacts,
+                  context: param2?.context
                 }
               );
             }`;
@@ -238,17 +255,16 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
         if (x.kind === "getList") {
             return `async ${x.methodName}(
             param1: { $where?: ${x.typeWhereName}, $orderBy?: ${x.typeOrderByName}, $limit?: number }, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string }
+            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
           ): Promise<Array<${x.typeReturnBaseName}>> {
             return this.runtime.resolve(
               {
-                table: "${x.table}",
-                fieldName: "${x.fieldName}",
+                resource: "${x.table}",
+                action: "findMany",
                 args: param1,
                 fields: param2?.fields,
-                grabMany: true,
                 artifacts,
-                kind: "list"
+                context: param2?.context
               }
             );
           }`;
@@ -256,17 +272,16 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
         if (x.kind === "getListPaginated") {
             return `async ${x.methodName}(
             param1: { $where?: ${x.typeWhereName}, $orderBy?: ${x.typeOrderByName}, $paginate: Paginate }, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string }
+            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
           ): Promise<ListPaginated<${x.typeReturnBaseName}>> {
             return this.runtime.resolve(
               {
-                table: "${x.table}",
-                fieldName: "${x.fieldName}",
+                resource: "${x.table}",
+                action: "findManyPaginated",
                 args: param1,
                 fields: param2?.fields,
-                grabMany: true,
                 artifacts,
-                kind: "listPaginated"
+                context: param2?.context
               }
             );
           }`;
@@ -274,19 +289,20 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
         if (x.kind === "postOne") {
             return `async ${x.methodName}(
             data: ${x.typeDataName}, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string }
+            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
           ): Promise<${x.typeReturnBaseName}> {
           let payload = data;
           ${specialCaseUuidColumn &&
                 uniqueColumns.find((x) => x.name === "uuid")
                 ? `if (!Object.prototype.hasOwnProperty.call(payload, "uuid")) { payload = {...payload, uuid: uuidv4()} }`
                 : ""}
-          return this.runtime.post({
-            table: "${x.table}",
+          return this.runtime.resolve({
+            resource: "${x.table}",
+            action: "create",
             data: payload,
             artifacts,
-            fieldName: "${x.fieldName}",
             fields: param2?.fields,
+            context: param2?.context
           });
         }`;
         }
@@ -296,15 +312,16 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
                 .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
                 .join(" | ")}, 
             data: ${x.typeDataName}, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string }
+            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
           ): Promise<${x.typeReturnBaseName}> {
-          return this.runtime.patch({
-            table: "${x.table}",
+          return this.runtime.resolve({
+            resource: "${x.table}",
+            action: "update",
             args: { $where: param1 },
             data,
             artifacts,
-            fieldName: "${x.fieldName}",
             fields: param2?.fields,
+            context: param2?.context
           });
         }`;
         }
@@ -312,15 +329,16 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
             return `async ${x.methodName}(
             param1: { $where?: ${x.typeWhereName} }, 
             data: ${x.typeDataName}, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string }
+            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
           ): Promise<Array<${x.typeReturnBaseName}>> {
-          return this.runtime.patchList({
-            table: "${x.table}",
+          return this.runtime.resolve({
+            resource: "${x.table}",
+            action: "updateMany",
             args: param1,
             data,
             artifacts,
-            fieldName: "${x.fieldName}",
             fields: param2?.fields,
+            context: param2?.context
           });
         }`;
         }
@@ -329,23 +347,28 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
               param1: ${findOnes
                 .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
                 .join(" | ")},
-            param2?: { correlationId?: string }
+            param2?: { correlationId?: string, context?: TContext }
           ): Promise<void> {
-            await this.runtime.del({
-              table: "${x.table}",
+            await this.runtime.resolve({
+              resource: "${x.table}",
+              action: "delete",
               args: { $where: param1 },
+              artifacts,
+              context: param2?.context
             });
           }`;
         }
         if (x.kind === "deleteList") {
             return `async ${x.methodName}(
             param1: { $where?: ${x.typeWhereName} },
-            param2?: { correlationId?: string }
+            param2?: { correlationId?: string, context?: TContext }
           ): Promise<void> {
-            await this.runtime.deleteList({
-              table: "${x.table}",
+            await this.runtime.resolve({
+              resource: "${x.table}",
+              action: "deleteMany",
               args: param1,
-              artifacts
+              artifacts,
+              context: param2?.context
             });
           }`;
         }
@@ -373,7 +396,6 @@ async function getGetOneData(table, includeMappedFields) {
         kind: "getOne",
         table,
         methodName: "get" + changeCase.pascalCase(table),
-        fieldName: changeCase.camelCase(table),
         typeFields: await getTypeFields(table, typeFieldsName, includeMappedFields),
         typeFieldsName,
         typeReturnBase: await getTypeReturnBase(table, typeReturnBaseName, includeMappedFields),
@@ -391,7 +413,6 @@ async function getGetListData(table) {
         kind: "getList",
         table,
         methodName: "get" + changeCase.pascalCase(table) + "List",
-        fieldName: changeCase.camelCase(table) + "List",
         typeFieldsName,
         typeReturnBaseName,
         typeWhere,
@@ -409,7 +430,6 @@ async function getGetListPaginatedData(table) {
         kind: "getListPaginated",
         table,
         methodName: "get" + changeCase.pascalCase(table) + "ListPaginated",
-        fieldName: changeCase.camelCase(table) + "ListPaginated",
         typeFieldsName,
         typeReturnBaseName,
         typeWhereName,
@@ -424,7 +444,6 @@ async function getPostOneData(table, specialCaseUuidColumn, includeMappedFields)
         kind: "postOne",
         table,
         methodName: "post" + changeCase.pascalCase(table),
-        fieldName: changeCase.camelCase(table),
         typeFieldsName,
         typeReturnBaseName,
         typeData: await getTypeDataPost(table, typeDataName, specialCaseUuidColumn, includeMappedFields),
@@ -439,7 +458,6 @@ async function getPatchOneData(table, specialCaseUuidColumn, includeMappedFields
         kind: "patchOne",
         table,
         methodName: "patch" + changeCase.pascalCase(table),
-        fieldName: changeCase.camelCase(table),
         typeFieldsName,
         typeReturnBaseName,
         typeData: await getTypeDataPatch(table, typeDataName, specialCaseUuidColumn, includeMappedFields),
@@ -455,7 +473,6 @@ async function getPatchListData(table) {
         kind: "patchList",
         table,
         methodName: "patch" + changeCase.pascalCase(table) + "List",
-        fieldName: changeCase.camelCase(table) + "List",
         typeFieldsName,
         typeReturnBaseName,
         typeWhereName,
@@ -467,7 +484,6 @@ function getDeleteOneData(table) {
         kind: "deleteOne",
         table,
         methodName: "delete" + changeCase.pascalCase(table),
-        fieldName: changeCase.camelCase(table),
     };
 }
 function getDeleteListData(table) {
@@ -476,13 +492,12 @@ function getDeleteListData(table) {
         kind: "deleteList",
         table,
         methodName: "delete" + changeCase.pascalCase(table) + "List",
-        fieldName: changeCase.camelCase(table) + "List",
         typeWhereName,
     };
 }
 async function getTypeWhere(table, name) {
     const jsonSchemaWhere = await getJSONSchemaWhere(table);
-    return json_schema_to_typescript_1.compile(jsonSchemaWhere, name);
+    return json_schema_to_typescript_1.compile(jsonSchemaWhere, name, json2TsOpts);
 }
 async function getTypeDataPost(table, name, specialCaseUuidColumn, includeMappedFields) {
     const primaryColumn = await getPrimaryColumn(table);
@@ -526,7 +541,7 @@ async function getTypeDataPost(table, name, specialCaseUuidColumn, includeMapped
             // for simplicity, just make both not required for now.
             .filter((x) => !notRequiredList.includes(x)),
     };
-    return json_schema_to_typescript_1.compile(jsonSchema, name);
+    return json_schema_to_typescript_1.compile(jsonSchema, name, json2TsOpts);
 }
 async function getTypeDataPatch(table, name, specialCaseUuidColumn, includeMappedFields) {
     const primaryColumn = await getPrimaryColumn(table);
@@ -571,7 +586,7 @@ async function getTypeDataPatch(table, name, specialCaseUuidColumn, includeMappe
         additionalProperties: false,
         required: [],
     };
-    let type = await json_schema_to_typescript_1.compile(jsonSchema, name);
+    let type = await json_schema_to_typescript_1.compile(jsonSchema, name, json2TsOpts);
     if (mustImportTUpdateOperationsString || mustImportTUpdateOperationsNumber) {
         const imports = [];
         if (mustImportTUpdateOperationsString) {
@@ -766,7 +781,7 @@ async function getJSONSchemaWhere(table) {
     };
 }
 async function getTypeOrderBy(table, name) {
-    return json_schema_to_typescript_1.compile((await getJSONSchemaOrderBy(table)), name);
+    return json_schema_to_typescript_1.compile((await getJSONSchemaOrderBy(table)), name, json2TsOpts);
 }
 async function getJSONSchemaOrderBy(table) {
     const fieldNames = await getTableMeta(table).then((xs) => xs.map((x) => x.Field));
@@ -876,7 +891,7 @@ async function getTypeFields(table, name, includeMappedFields) {
             ],
         },
     };
-    let type = await json_schema_to_typescript_1.compile(jsonSchemaFields, name);
+    let type = await json_schema_to_typescript_1.compile(jsonSchemaFields, name, json2TsOpts);
     const fieldImports = _.uniq(relations
         .filter((x) => x.table !== table)
         .map((x) => getTypeFieldsName(x.table)));
@@ -924,7 +939,7 @@ async function getTypeReturnBase(table, name, includeMappedFields) {
         // Because of aliases
         additionalProperties: true,
     };
-    let type = await json_schema_to_typescript_1.compile(jsonSchemaReturn, name);
+    let type = await json_schema_to_typescript_1.compile(jsonSchemaReturn, name, json2TsOpts);
     const imports = _.uniq(relations.map((x) => getTypeReturnBaseName(x.table)))
         .filter((x) => x !== name)
         .map((x) => `import type { ${x} } from "./${x}";`)
@@ -998,7 +1013,11 @@ async function getArtifactsSource(tables, includeMappedFields) {
         acc[x.table] = x;
         return acc;
     }, {});
-    const src = `export const artifacts = ${JSON.stringify(artifacts)}`;
+    const src = `
+  import type {IArtifacts} from "./IRuntime";
+
+  export const artifacts: IArtifacts = ${JSON.stringify(artifacts)};
+  `;
     return prettier.format(src, { parser: "typescript" });
 }
 const getRelationInfo = _.memoize(async function getRelationInfo(table) {

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { generate } from "./generate";
-export { SDKNotFoundError } from "./SDKNotFoundError";
+export { generate } from "./generation/generate";
+export { SDKNotFoundError } from "./runtime/lib/SDKNotFoundError";

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDKNotFoundError = exports.generate = void 0;
-var generate_1 = require("./generate");
+var generate_1 = require("./generation/generate");
 Object.defineProperty(exports, "generate", { enumerable: true, get: function () { return generate_1.generate; } });
-var SDKNotFoundError_1 = require("./SDKNotFoundError");
+var SDKNotFoundError_1 = require("./runtime/lib/SDKNotFoundError");
 Object.defineProperty(exports, "SDKNotFoundError", { enumerable: true, get: function () { return SDKNotFoundError_1.SDKNotFoundError; } });

package/dist/runtime/IRuntime.d.ts

@@ -1,47 +1,160 @@
-import { IArtifacts, IGetSQLASTInput } from "../types";
 export interface IRuntime {
-    resolve(input: TResolveInput): Promise<any>;
-    post(input: TPostInput): Promise<any>;
-    patch(input: TPatchInput): Promise<any>;
-    patchList(input: TPatchListInput): Promise<any>;
-    del(input: TDelInput): Promise<any>;
-    deleteList(input: TDeleteListInput): Promise<any>;
-    whereNeedsProcessing(where: any): boolean;
-    _prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<any>;
+    resolve(input: TResolveParams): Promise<any>;
+    $use: (middleware: TMiddleware) => void;
+    $whereNeedsProcessing(where: any): boolean;
+    $prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<any>;
 }
-export declare type TResolveInput = Omit<IGetSQLASTInput, "getWhere" | "where" | "dialect"> & {
-    fields: IGetSQLASTInput["fields"] | undefined;
-    kind?: "list" | "listPaginated";
-};
-export declare type TPostInput = {
-    table: TResolveInput["table"];
-    data: any;
-    artifacts: TResolveInput["artifacts"];
-    fields: TResolveInput["fields"];
-    fieldName: TResolveInput["fieldName"];
-};
-export declare type TPatchInput = {
-    table: TResolveInput["table"];
-    args: TResolveInput["args"];
-    data: any;
-    artifacts: TResolveInput["artifacts"];
-    fields: TResolveInput["fields"];
-    fieldName: TResolveInput["fieldName"];
-};
-export declare type TPatchListInput = {
-    table: TResolveInput["table"];
-    args: TResolveInput["args"];
-    data: any;
-    artifacts: TResolveInput["artifacts"];
-    fields: TResolveInput["fields"];
-    fieldName: TResolveInput["fieldName"];
-};
-export declare type TDelInput = {
-    table: TResolveInput["table"];
-    args: TResolveInput["args"];
-};
-export declare type TDeleteListInput = {
-    table: TResolveInput["table"];
-    args: TResolveInput["args"];
+export declare type TResolveParams = {
+    resource: string;
+    action: "findUnique" | "findMany" | "findManyPaginated" | "create" | "update" | "updateMany" | "delete" | "deleteMany";
+    args?: IArgs | undefined;
+    data?: any;
     artifacts: IArtifacts;
+    fields?: IField[] | undefined;
+    context?: TContext | undefined;
 };
+export declare type TContext = {
+    [k: string]: any;
+};
+export declare type TMiddleware = (params: TResolveParams, next: (params: TResolveParams) => Promise<any>) => Promise<any>;
+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;
+};
+export declare type IField = string | {
+    name: string;
+    as?: string;
+    fields: 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: IField[];
+    args?: IArgs;
+    where?: IWhere;
+    sqlJoin?: ISqlJoin;
+    sqlBatch?: ISqlBatch;
+    junction?: IJunction;
+    grabMany: boolean;
+    getWhere: (table: string, args: any, dialect: IDialect, orderBy?: IOrderBy | undefined, rowWithMatchingCursor?: any) => string | null;
+    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 {};