@technicity/data-service-generator 0.12.0-next.0 → 0.12.1

package/dist/generation/generate.js

@@ -25,7 +25,7 @@ const MySQL_1 = require("../runtime/lib/MySQL");
 let query = undefined;
 let dialect = "mysql";
 const json2TsOpts = {
-    bannerComment: "",
+    bannerComment: ""
 };
 async function generate(input) {
     if (input.tables != null && input.excludeTables != null) {
@@ -57,7 +57,7 @@ async function generate(input) {
         getPatchOneData(x, specialCaseUuidColumn, includeMappedFields),
         getPatchListData(x),
         getDeleteOneData(x),
-        getDeleteListData(x),
+        getDeleteListData(x)
     ]));
     const artifactsSource = await getArtifactsSource(tables, includeMappedFields, specialCaseUuidColumn);
     const sdkSource = await getSDKSource(data, specialCaseUuidColumn, supplementClientOpts);
@@ -70,9 +70,9 @@ async function generate(input) {
             moduleResolution: "node",
             target: "es2020",
             declaration: true,
-            outDir: "./sdk-ts",
+            outDir: "./sdk-ts"
         },
-        include: [sdkFilename, artifactsFilename, IRuntimeFilename],
+        include: [sdkFilename, artifactsFilename, IRuntimeFilename]
     };
     const packageJSON = {
         name: "temp",
@@ -81,8 +81,8 @@ async function generate(input) {
         dependencies: require("../../package.json").dependencies,
         devDependencies: {
             "@types/node": require("../../package.json").devDependencies["@types/node"],
-            typescript: require("../../package.json").devDependencies.typescript,
-        },
+            typescript: require("../../package.json").devDependencies.typescript
+        }
     };
     const tmpDirPath = path.join(os.tmpdir(), `dsg-${(0, uuid_1.v4)()}`);
     fse.mkdirpSync(tmpDirPath);
@@ -145,7 +145,7 @@ function init(input) {
             password,
             host,
             port,
-            database,
+            database
         });
         query = mysql.query.bind(mysql);
     }
@@ -155,7 +155,7 @@ function init(input) {
             user,
             password,
             port,
-            database,
+            database
         });
         const poolConnect = pool.connect();
         async function runMSSQLQuery(...input) {
@@ -179,7 +179,7 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
                 "typeReturnBaseName",
                 "typeWhereName",
                 "typeOrderByName",
-                "typeDataName",
+                "typeDataName"
             ]) {
                 const str = d[k];
                 if (str) {
@@ -191,6 +191,21 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
             .concat(Array.from(set).sort())
             .join(",\n")} } from "./types";`;
     }
+    function getTypeNullResponses() {
+        return `type TNullResponses = { ${Object.entries(_.groupBy((x) => x.table, input))
+            .flatMap(([table, xx]) => {
+            const name = table;
+            return (`${name}: {` +
+                xx
+                    .map(({ kind }) => {
+                    const operation = mapKindToAction(kind);
+                    return `${operation}: (input: { args: { select: Fields${table} | undefined, where: Where${table} | undefined }, model: "${table}", operation: "${operation}" }) => Promise<ReturnBase${table}>`;
+                })
+                    .join(",") +
+                " } ");
+        })
+            .join(",")} }`;
+    }
     const src = `import type { IRuntime, TMiddleware, TContext } from "./IRuntime"
   import { artifacts } from "./artifacts";
 
@@ -198,16 +213,33 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
 
   export class SDK {
     runtime: IRuntime;
+    _nullability: TNullResponses | undefined;
   
+    static create(opts: {
+      runtime: any;
+      clientOpts: { [k: string]: any; },
+      otherOpts?: { [k: string]: any; }
+     }) {
+      return new this(opts);
+    }
+
+    static createNull(opts: {
+      runtime: any;
+      query?: TNullResponses
+     }) {
+      return new this({ runtime: opts.runtime, clientOpts: {}, otherOpts: { nullability: opts.query } });
+    }
+
     constructor(opts: {
       runtime: any;
       clientOpts: { [k: string]: any; },
       otherOpts?: { [k: string]: any; }
      }) {
-      opts.otherOpts = opts.otherOpts ?? {}
+      const { nullability, ...otherOpts } = opts.otherOpts ?? {};
       this.runtime = new opts.runtime(opts.clientOpts, ${supplementClientOpts === true
-        ? "{ supplementClientOpts: true, ...opts.otherOpts }"
-        : "opts.otherOpts"}, artifacts);
+        ? "{ supplementClientOpts: true, ...otherOpts }"
+        : "otherOpts"}, artifacts);
+      this._nullability = nullability;
     }
 
     $use(middleware: TMiddleware) {
@@ -233,159 +265,278 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
       return this.runtime.$shutdown();
     }
 
+    async $startTransaction(input?: {
+      isolationLevel?:
+        | "READ UNCOMMITTED"
+        | "READ COMMITTED"
+        | "REPEATABLE READ"
+        | "SERIALIZABLE"
+    }) {
+      const { dbCall, commit, rollback } = await this.runtime.$startTransaction(input);
+      const runtime = this.runtime;
+      return {
+        $commit: commit,
+        $rollback: rollback,
+        ${(await Promise.all(input.flatMap(async (x) => {
+        if (x.kind === "getOne") {
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourceGetOne(x, findOnes, true);
+        }
+        if (x.kind === "getList") {
+            return getMethodSourceGetList(x, true);
+        }
+        if (x.kind === "getListPaginated") {
+            return getMethodSourceGetListPaginated(x, true);
+        }
+        if (x.kind === "postOne") {
+            return getMethodSourcePostOne(x, specialCaseUuidColumn, true);
+        }
+        if (x.kind === "patchOne") {
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourcePatchOne(x, findOnes, true);
+        }
+        if (x.kind === "patchList") {
+            return getMethodSourcePatchList(x, true);
+        }
+        if (x.kind === "deleteOne") {
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourceDeleteOne(x, findOnes, true);
+        }
+        if (x.kind === "deleteList") {
+            return getMethodSourceDeleteList(x, true);
+        }
+    }))).join(",\n")}
+      }
+    }
+
     ${(await Promise.all(input.flatMap(async (x) => {
-        let findOnes = [];
-        const primaryColumn = await getPrimaryColumn(x.table);
-        const uniqueColumns = await getUniqueColumns(x.table, specialCaseUuidColumn);
-        findOnes = findOnes
-            .concat([primaryColumn])
-            .concat(uniqueColumns)
-            .map((x) => ({
-            ...x,
-            type: x.type === "integer" ? "number" : x.type,
-        }));
         if (x.kind === "getOne") {
-            return `async ${x.methodName}(
-                param1: ${findOnes
-                .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
-                .join(" | ")}, 
-                param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, skipCache?: boolean, context?: TContext }
-              ): Promise<${x.typeReturnBaseName}> {
-              return this.runtime.resolve(
-                {
-                  resource: "${x.table}",
-                  action: "findUnique",
-                  args: { $where: param1 },
-                  fields: param2?.fields,
-                  artifacts,
-                  context: param2?.context,
-                  skipCache: param2?.skipCache
-                }
-              );
-            }`;
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourceGetOne(x, findOnes, false);
         }
         if (x.kind === "getList") {
-            return `async ${x.methodName}(
-            param1: { $where?: ${x.typeWhereName}, $orderBy?: ${x.typeOrderByName}, $limit?: number }, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, skipCache?: boolean, context?: TContext }
-          ): Promise<Array<${x.typeReturnBaseName}>> {
-            return this.runtime.resolve(
-              {
-                resource: "${x.table}",
-                action: "findMany",
-                args: param1,
-                fields: param2?.fields,
-                artifacts,
-                context: param2?.context,
-                skipCache: param2?.skipCache
-              }
-            );
-          }`;
+            return getMethodSourceGetList(x, false);
         }
         if (x.kind === "getListPaginated") {
-            return `async ${x.methodName}(
-            param1: { $where?: ${x.typeWhereName}, $orderBy?: ${x.typeOrderByName}, $paginate: Paginate }, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, skipCache?: boolean, context?: TContext }
-          ): Promise<ListPaginated<${x.typeReturnBaseName}>> {
-            return this.runtime.resolve(
-              {
-                resource: "${x.table}",
-                action: "findManyPaginated",
-                args: param1,
-                fields: param2?.fields,
-                artifacts,
-                context: param2?.context,
-                skipCache: param2?.skipCache
-              }
-            );
-          }`;
+            return getMethodSourceGetListPaginated(x, false);
         }
         if (x.kind === "postOne") {
-            return `async ${x.methodName}(
-            data: ${x.typeDataName}, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
-          ): Promise<${x.typeReturnBaseName}> {
-          return this.runtime.resolve({
-            resource: "${x.table}",
-            action: "create",
-            data,
-            artifacts,
-            fields: param2?.fields,
-            context: {...param2?.context, specialCaseUuidColumn: ${JSON.stringify(specialCaseUuidColumn)}}
-          });
-        }`;
+            return getMethodSourcePostOne(x, specialCaseUuidColumn, false);
         }
         if (x.kind === "patchOne") {
-            return `async ${x.methodName}(
-              param1: ${findOnes
-                .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
-                .join(" | ")}, 
-            data: ${x.typeDataName}, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
-          ): Promise<${x.typeReturnBaseName}> {
-          return this.runtime.resolve({
-            resource: "${x.table}",
-            action: "update",
-            args: { $where: param1 },
-            data,
-            artifacts,
-            fields: param2?.fields,
-            context: param2?.context
-          });
-        }`;
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourcePatchOne(x, findOnes, false);
         }
         if (x.kind === "patchList") {
-            return `async ${x.methodName}(
-            param1: { $where?: ${x.typeWhereName} }, 
-            data: ${x.typeDataName}, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
-          ): Promise<Array<${x.typeReturnBaseName}>> {
-          return this.runtime.resolve({
-            resource: "${x.table}",
-            action: "updateMany",
-            args: param1,
-            data,
-            artifacts,
-            fields: param2?.fields,
-            context: param2?.context
-          });
-        }`;
+            return getMethodSourcePatchList(x, false);
         }
         if (x.kind === "deleteOne") {
-            return `async ${x.methodName}(
-              param1: ${findOnes
-                .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
-                .join(" | ")},
-            param2?: { correlationId?: string, context?: TContext }
-          ): Promise<void> {
-            await this.runtime.resolve({
-              resource: "${x.table}",
-              action: "delete",
-              args: { $where: param1 },
-              artifacts,
-              context: param2?.context
-            });
-          }`;
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourceDeleteOne(x, findOnes, false);
         }
         if (x.kind === "deleteList") {
-            return `async ${x.methodName}(
-            param1: { $where?: ${x.typeWhereName} },
-            param2?: { correlationId?: string, context?: TContext }
-          ): Promise<void> {
-            await this.runtime.resolve({
-              resource: "${x.table}",
-              action: "deleteMany",
-              args: param1,
-              artifacts,
-              context: param2?.context
-            });
-          }`;
+            return getMethodSourceDeleteList(x, false);
         }
     }))).join("\n\n")}
   }
+
+  ${getTypeNullResponses()}
   `;
     return prettier.format(src, { parser: "typescript" });
 }
+async function getFindOnes(x, specialCaseUuidColumn) {
+    let findOnes = [];
+    const primaryColumn = await getPrimaryColumn(x.table);
+    const uniqueColumns = await getUniqueColumns(x.table, specialCaseUuidColumn);
+    findOnes = findOnes
+        .concat([primaryColumn])
+        .concat(uniqueColumns)
+        .map((x) => ({
+        ...x,
+        type: x.type === "integer" ? "number" : x.type
+    }));
+    return findOnes;
+}
+function getMethodSourceGetOne(x, findOnes, isTransaction) {
+    return `async ${x.methodName}(
+    param1: ${findOnes
+        .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
+        .join(" | ")}, 
+    param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, skipCache?: boolean, context?: TContext }
+  ): Promise<${x.typeReturnBaseName}> {
+  return ${isTransaction ? "runtime" : "this.runtime"}.resolve(
+    {
+      resource: "${x.table}",
+      action: "${mapKindToAction(x.kind)}",
+      args: { $where: param1 },
+      fields: param2?.fields,
+      artifacts,
+      context: param2?.context,
+      skipCache: param2?.skipCache,
+      nullability: this._nullability,
+      ${isTransaction ? "dbCall" : ""}
+    }
+  );
+}`;
+}
+function getMethodSourceGetList(x, isTransaction) {
+    return `async ${x.methodName}(
+    param1: { $where?: ${x.typeWhereName}, $orderBy?: ${x.typeOrderByName}, $limit?: number },
+    param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, skipCache?: boolean, context?: TContext }
+  ): Promise<Array<${x.typeReturnBaseName}>> {
+    return ${isTransaction ? "runtime" : "this.runtime"}.resolve(
+      {
+        resource: "${x.table}",
+        action: "${mapKindToAction(x.kind)}",
+        args: param1,
+        fields: param2?.fields,
+        artifacts,
+        context: param2?.context,
+        skipCache: param2?.skipCache,
+        nullability: this._nullability,
+        ${isTransaction ? "dbCall" : ""}
+      }
+    );
+  }`;
+}
+function getMethodSourceGetListPaginated(x, isTransaction) {
+    return `async ${x.methodName}(
+    param1: { $where?: ${x.typeWhereName}, $orderBy?: ${x.typeOrderByName}, $paginate: Paginate },
+    param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, skipCache?: boolean, context?: TContext }
+  ): Promise<ListPaginated<${x.typeReturnBaseName}>> {
+    return ${isTransaction ? "runtime" : "this.runtime"}.resolve(
+      {
+        resource: "${x.table}",
+        action: "${mapKindToAction(x.kind)}",
+        args: param1,
+        fields: param2?.fields,
+        artifacts,
+        context: param2?.context,
+        skipCache: param2?.skipCache,
+        nullability: this._nullability,
+        ${isTransaction ? "dbCall" : ""}
+      }
+    );
+  }`;
+}
+function getMethodSourcePostOne(x, specialCaseUuidColumn, isTransaction) {
+    return `async ${x.methodName}(
+    data: ${x.typeDataName},
+    param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
+  ): Promise<${x.typeReturnBaseName}> {
+  return ${isTransaction ? "runtime" : "this.runtime"}.resolve({
+    resource: "${x.table}",
+    action: "${mapKindToAction(x.kind)}",
+    data,
+    artifacts,
+    fields: param2?.fields,
+    context: {...param2?.context, specialCaseUuidColumn: ${JSON.stringify(specialCaseUuidColumn)}},
+    nullability: this._nullability,
+    ${isTransaction ? "dbCall" : ""}
+  });
+}`;
+}
+function getMethodSourcePatchOne(x, findOnes, isTransaction) {
+    return `async ${x.methodName}(
+    param1: ${findOnes
+        .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
+        .join(" | ")},
+  data: ${x.typeDataName},
+  param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
+): Promise<${x.typeReturnBaseName}> {
+return ${isTransaction ? "runtime" : "this.runtime"}.resolve({
+  resource: "${x.table}",
+  action: "${mapKindToAction(x.kind)}",
+  args: { $where: param1 },
+  data,
+  artifacts,
+  fields: param2?.fields,
+  context: param2?.context,
+  nullability: this._nullability,
+  ${isTransaction ? "dbCall" : ""}
+});
+}`;
+}
+function getMethodSourcePatchList(x, isTransaction) {
+    return `async ${x.methodName}(
+    param1: { $where?: ${x.typeWhereName} },
+    data: ${x.typeDataName},
+    param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
+  ): Promise<Array<${x.typeReturnBaseName}>> {
+  return ${isTransaction ? "runtime" : "this.runtime"}.resolve({
+    resource: "${x.table}",
+    action: "${mapKindToAction(x.kind)}",
+    args: param1,
+    data,
+    artifacts,
+    fields: param2?.fields,
+    context: param2?.context,
+    nullability: this._nullability,
+    ${isTransaction ? "dbCall" : ""}
+  });
+}`;
+}
+function getMethodSourceDeleteOne(x, findOnes, isTransaction) {
+    return `async ${x.methodName}(
+    param1: ${findOnes
+        .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
+        .join(" | ")},
+  param2?: { correlationId?: string, context?: TContext }
+): Promise<void> {
+  await ${isTransaction ? "runtime" : "this.runtime"}.resolve({
+    resource: "${x.table}",
+    action: "${mapKindToAction(x.kind)}",
+    args: { $where: param1 },
+    artifacts,
+    context: param2?.context,
+    nullability: this._nullability,
+    ${isTransaction ? "dbCall" : ""}
+  });
+}`;
+}
+function getMethodSourceDeleteList(x, isTransaction) {
+    return `async ${x.methodName}(
+    param1: { $where?: ${x.typeWhereName} },
+    param2?: { correlationId?: string, context?: TContext }
+  ): Promise<void> {
+    await ${isTransaction ? "runtime" : "this.runtime"}.resolve({
+      resource: "${x.table}",
+      action: "${mapKindToAction(x.kind)}",
+      args: param1,
+      artifacts,
+      context: param2?.context,
+      nullability: this._nullability,
+      ${isTransaction ? "dbCall" : ""}
+    });
+  }`;
+}
+function mapKindToAction(kind) {
+    if (kind === "getOne") {
+        return "findUnique";
+    }
+    if (kind === "getList") {
+        return "findMany";
+    }
+    if (kind === "getListPaginated") {
+        return "findManyPaginated";
+    }
+    if (kind === "postOne") {
+        return "create";
+    }
+    if (kind === "patchOne") {
+        return "update";
+    }
+    if (kind === "patchList") {
+        return "updateMany";
+    }
+    if (kind === "deleteOne") {
+        return "delete";
+    }
+    if (kind === "deleteList") {
+        return "deleteMany";
+    }
+    throw new Error(`Unhandled kind: ${kind}`);
+}
 function getTypeReturnBaseName(table) {
     return "ReturnBase" + changeCase.pascalCase(table);
 }
@@ -411,7 +562,7 @@ async function getGetOneData(table, includeMappedFields) {
         typeFields: await getTypeFields(table, typeFieldsName, includeMappedFields),
         typeFieldsName,
         typeReturnBase: await getTypeReturnBase(table, typeReturnBaseName, includeMappedFields),
-        typeReturnBaseName,
+        typeReturnBaseName
     };
 }
 async function getGetListData(table) {
@@ -430,7 +581,7 @@ async function getGetListData(table) {
         typeWhere,
         typeWhereName,
         typeOrderBy,
-        typeOrderByName,
+        typeOrderByName
     };
 }
 async function getGetListPaginatedData(table) {
@@ -445,7 +596,7 @@ async function getGetListPaginatedData(table) {
         typeFieldsName,
         typeReturnBaseName,
         typeWhereName,
-        typeOrderByName,
+        typeOrderByName
     };
 }
 async function getPostOneData(table, specialCaseUuidColumn, includeMappedFields) {
@@ -459,7 +610,7 @@ async function getPostOneData(table, specialCaseUuidColumn, includeMappedFields)
         typeFieldsName,
         typeReturnBaseName,
         typeData: await getTypeDataPost(table, typeDataName, specialCaseUuidColumn, includeMappedFields),
-        typeDataName,
+        typeDataName
     };
 }
 async function getPatchOneData(table, specialCaseUuidColumn, includeMappedFields) {
@@ -473,7 +624,7 @@ async function getPatchOneData(table, specialCaseUuidColumn, includeMappedFields
         typeFieldsName,
         typeReturnBaseName,
         typeData: await getTypeDataPatch(table, typeDataName, specialCaseUuidColumn, includeMappedFields),
-        typeDataName,
+        typeDataName
     };
 }
 async function getPatchListData(table) {
@@ -488,14 +639,14 @@ async function getPatchListData(table) {
         typeFieldsName,
         typeReturnBaseName,
         typeWhereName,
-        typeDataName,
+        typeDataName
     };
 }
 function getDeleteOneData(table) {
     return {
         kind: "deleteOne",
         table,
-        methodName: "delete" + changeCase.pascalCase(table),
+        methodName: "delete" + changeCase.pascalCase(table)
     };
 }
 function getDeleteListData(table) {
@@ -504,7 +655,7 @@ function getDeleteListData(table) {
         kind: "deleteList",
         table,
         methodName: "delete" + changeCase.pascalCase(table) + "List",
-        typeWhereName,
+        typeWhereName
     };
 }
 async function getTypeWhere(table, name) {
@@ -516,11 +667,11 @@ async function getTypeDataPost(table, name, specialCaseUuidColumn, includeMapped
     const tableMeta = (await getTableMeta(table)).filter((x) => x.Field !== primaryColumn.name);
     const nullable = tableMeta.reduce((acc, m) => ({
         ...acc,
-        [m.Field]: m.Null === "YES" ? true : false,
+        [m.Field]: m.Null === "YES" ? true : false
     }), {});
     const hasDefault = tableMeta.reduce((acc, m) => ({
         ...acc,
-        [m.Field]: m.Default == null ? false : true,
+        [m.Field]: m.Default == null ? false : true
     }), {});
     let properties = getJSONSchemaObjProperties(tableMeta);
     let notRequiredList = [];
@@ -533,7 +684,7 @@ async function getTypeDataPost(table, name, specialCaseUuidColumn, includeMapped
             ...mappedFields.reduce((acc, v) => {
                 acc[v.as] = { type: getJSONTypes(v.type, v.nullable) };
                 return acc;
-            }, {}),
+            }, {})
         };
         notRequiredList = mappedFields.flatMap((x) => [x.as, x.foreignKey]);
         for (let r of oneToManyRelations) {
@@ -548,9 +699,7 @@ async function getTypeDataPost(table, name, specialCaseUuidColumn, includeMapped
             ...oneToManyRelations.reduce((acc, v) => {
                 let tsType = getTypeDataPostName(v.table);
                 const mappedFields = mappedFieldsMap.get(v.table);
-                if (includeMappedFields &&
-                    mappedFields != null &&
-                    mappedFields.length > 0) {
+                if (includeMappedFields && mappedFields != null && mappedFields.length > 0) {
                     tsType = `Omit<${tsType}, ${mappedFields
                         .map((x) => JSON.stringify(x.as))
                         .join(" | ")}>`;
@@ -558,21 +707,19 @@ async function getTypeDataPost(table, name, specialCaseUuidColumn, includeMapped
                 tsType = `{$create: ${tsType}[]}`;
                 acc[v.name] = { tsType };
                 return acc;
-            }, {}),
+            }, {})
         },
         additionalProperties: false,
         required: Object.keys(properties)
             .filter(
         // `uuid` should not be required
-        (x) => !specialCaseUuidColumn || uuidColumn == null
-            ? true
-            : x !== uuidColumn.name)
+        (x) => !specialCaseUuidColumn || uuidColumn == null ? true : x !== uuidColumn.name)
             .filter(
         // Required if column is non-nullable and has no default.
         (x) => !nullable[x] && !hasDefault[x])
             // Instead of doing a union with all possible permutations of UUID and IDs,
             // for simplicity, just make both not required for now.
-            .filter((x) => !notRequiredList.includes(x)),
+            .filter((x) => !notRequiredList.includes(x))
     };
     let type = await (0, json_schema_to_typescript_1.compile)(jsonSchema, name, json2TsOpts);
     const imports = _.uniq(oneToManyRelations
@@ -601,13 +748,13 @@ async function getTypeDataPatch(table, name, specialCaseUuidColumn, includeMappe
         const type = unwrapJSONType(properties[key].type);
         if (type === "string") {
             properties[key] = {
-                oneOf: [properties[key], { tsType: "TUpdateOperationsString" }],
+                oneOf: [properties[key], { tsType: "TUpdateOperationsString" }]
             };
             mustImportTUpdateOperationsString = true;
         }
         else if (type === "number" || type === "integer") {
             properties[key] = {
-                oneOf: [properties[key], { tsType: "TUpdateOperationsNumber" }],
+                oneOf: [properties[key], { tsType: "TUpdateOperationsNumber" }]
             };
             mustImportTUpdateOperationsNumber = true;
         }
@@ -619,14 +766,14 @@ async function getTypeDataPatch(table, name, specialCaseUuidColumn, includeMappe
             ...mappedFields.reduce((acc, v) => {
                 acc[v.as] = { type: getJSONTypes(v.type, v.nullable) };
                 return acc;
-            }, {}),
+            }, {})
         };
     }
     const jsonSchema = {
         type: "object",
         properties,
         additionalProperties: false,
-        required: [],
+        required: []
     };
     let type = await (0, json_schema_to_typescript_1.compile)(jsonSchema, name, json2TsOpts);
     if (mustImportTUpdateOperationsString || mustImportTUpdateOperationsNumber) {
@@ -669,7 +816,7 @@ async function getMappedFields(table) {
             name: "uuid",
             // Replace `Id` with `Uuid`
             as: x.foreignKey.slice(0, -2) + "Uuid",
-            type: getBaseJSONType(uuidColumn.Type),
+            type: getBaseJSONType(uuidColumn.Type)
         });
     }
     return out;
@@ -688,52 +835,52 @@ async function getJSONSchemaWhere(table) {
                             {
                                 type: "object",
                                 properties: { $eq: v },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $neq: v },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $gt: v },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $gte: v },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $lt: v },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $lte: v },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $like: { type: "string", minLength: 1 } },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $nlike: { type: "string", minLength: 1 } },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $in: { type: "array", items: v } },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $nin: { type: "array", items: v } },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
@@ -743,10 +890,10 @@ async function getJSONSchemaWhere(table) {
                                         items: v,
                                         minItems: 2,
                                         maxItems: 2,
-                                        uniqueItems: true,
-                                    },
+                                        uniqueItems: true
+                                    }
                                 },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
@@ -756,15 +903,15 @@ async function getJSONSchemaWhere(table) {
                                         items: v,
                                         minItems: 2,
                                         maxItems: 2,
-                                        uniqueItems: true,
-                                    },
+                                        uniqueItems: true
+                                    }
                                 },
-                                additionalProperties: false,
-                            },
-                        ],
-                    },
+                                additionalProperties: false
+                            }
+                        ]
+                    }
                 }), {}),
-                additionalProperties: false,
+                additionalProperties: false
             },
             {
                 type: "object",
@@ -772,17 +919,17 @@ async function getJSONSchemaWhere(table) {
                     $and: {
                         type: "array",
                         items: {
-                            $ref: `#/definitions/${whereSchemaName}`,
+                            $ref: `#/definitions/${whereSchemaName}`
                         },
                         // While it makes sense conceptually for $and to have
                         // at least 2 items, in practice, $and could be
                         // generated dynamically and could end up having
                         // less than 2 items, so don't enforce minItems.
                         // minItems: 2,
-                        additionalProperties: false,
-                    },
+                        additionalProperties: false
+                    }
                 },
-                additionalProperties: false,
+                additionalProperties: false
             },
             {
                 type: "object",
@@ -790,19 +937,19 @@ async function getJSONSchemaWhere(table) {
                     $or: {
                         type: "array",
                         items: {
-                            $ref: `#/definitions/${whereSchemaName}`,
+                            $ref: `#/definitions/${whereSchemaName}`
                         },
                         // While it makes sense conceptually for $and to have
                         // at least 2 items, in practice, $and could be
                         // generated dynamically and could end up having
                         // less than 2 items, so don't enforce minItems.
                         // minItems: 2,
-                        additionalProperties: false,
-                    },
+                        additionalProperties: false
+                    }
                 },
-                additionalProperties: false,
-            },
-        ],
+                additionalProperties: false
+            }
+        ]
     };
     return {
         definitions: { [whereSchemaName]: defWhere },
@@ -819,12 +966,12 @@ async function getJSONSchemaWhere(table) {
                         // generated dynamically and could end up having
                         // less than 2 items, so don't enforce minItems.
                         // minItems: 2,
-                        additionalProperties: false,
-                    },
+                        additionalProperties: false
+                    }
                 },
-                additionalProperties: false,
-            })),
-        ],
+                additionalProperties: false
+            }))
+        ]
     };
 }
 async function getTypeOrderBy(table, name) {
@@ -837,14 +984,14 @@ async function getJSONSchemaOrderBy(table, name) {
             type: "object",
             properties: { [k]: { enum: ["asc", "desc"] } },
             required: [k],
-            additionalProperties: false,
-        })),
+            additionalProperties: false
+        }))
     };
     const defName = `_${name}`;
     const _schema = { $ref: `#/definitions/${defName}` };
     return {
         definitions: { [defName]: def },
-        oneOf: [_schema, { type: "array", items: _schema }],
+        oneOf: [_schema, { type: "array", items: _schema }]
     };
 }
 function getTypeTypesIndex(data) {
@@ -858,7 +1005,7 @@ function getTypeTypesIndex(data) {
             "typeReturnBaseName",
             "typeWhereName",
             "typeOrderByName",
-            "typeDataName",
+            "typeDataName"
         ]) {
             const str = d[k];
             if (str) {
@@ -870,7 +1017,7 @@ function getTypeTypesIndex(data) {
         "Paginate",
         "ListPaginated",
         "TUpdateOperationsString",
-        "TUpdateOperationsNumber",
+        "TUpdateOperationsNumber"
     ].join(",")} } from "./_shared";\n\n`;
     let arr = Array.from(set).sort();
     for (let x of arr) {
@@ -920,7 +1067,7 @@ async function getTypeFields(table, name, includeMappedFields) {
         items: {
             anyOf: [
                 {
-                    enum: scalarKeys.concat(mappedFields.map((x) => x.as)),
+                    enum: scalarKeys.concat(mappedFields.map((x) => x.as))
                 },
                 ...relations.map((x) => {
                     const argsProperties = x.type === "many-to-many"
@@ -930,17 +1077,17 @@ async function getTypeFields(table, name, includeMappedFields) {
                                 properties: {
                                     [x.table]: { tsType: getTypeWhereName(x.table) },
                                     [x.junctionTable]: {
-                                        tsType: getTypeWhereName(x.junctionTable),
-                                    },
+                                        tsType: getTypeWhereName(x.junctionTable)
+                                    }
                                 },
-                                additionalProperties: false,
-                            },
+                                additionalProperties: false
+                            }
                         }
                         : { [keyWhere]: { tsType: getTypeWhereName(x.table) } };
                     // $orderBy only makes sense for a list
                     if (x.grabMany) {
                         argsProperties[keyOrderBy] = {
-                            tsType: getTypeOrderByName(x.table),
+                            tsType: getTypeOrderByName(x.table)
                         };
                     }
                     return {
@@ -952,21 +1099,19 @@ async function getTypeFields(table, name, includeMappedFields) {
                             args: {
                                 type: "object",
                                 properties: argsProperties,
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
-                            transform: { tsType: `(x: any) => any` },
+                            transform: { tsType: `(x: any) => any` }
                         },
                         additionalProperties: false,
-                        required: ["name", "fields"],
+                        required: ["name", "fields"]
                     };
-                }),
-            ],
-        },
+                })
+            ]
+        }
     };
     let type = await (0, json_schema_to_typescript_1.compile)(jsonSchemaFields, name, json2TsOpts);
-    const fieldImports = _.uniq(relations
-        .filter((x) => x.table !== table)
-        .map((x) => getTypeFieldsName(x.table)));
+    const fieldImports = _.uniq(relations.filter((x) => x.table !== table).map((x) => getTypeFieldsName(x.table)));
     const whereImports = _.uniq(relations.flatMap((x) => x.type === "many-to-many"
         ? [getTypeWhereName(x.table), getTypeWhereName(x.junctionTable)]
         : getTypeWhereName(x.table)));
@@ -1006,10 +1151,10 @@ async function getTypeReturnBase(table, name, includeMappedFields) {
                     acc[key] = { tsType };
                 }
                 return acc;
-            }, {}),
+            }, {})
         },
         // Because of aliases
-        additionalProperties: true,
+        additionalProperties: true
     };
     let type = await (0, json_schema_to_typescript_1.compile)(jsonSchemaReturn, name, json2TsOpts);
     const imports = _.uniq(relations.map((x) => getTypeReturnBaseName(x.table)))
@@ -1040,7 +1185,7 @@ async function getArtifactsSource(tables, includeMappedFields, specialCaseUuidCo
                     table: x.table,
                     grabMany: x.grabMany,
                     nullable: x.nullable,
-                    relation: x.relation,
+                    relation: x.relation
                 };
             }
             else {
@@ -1050,14 +1195,12 @@ async function getArtifactsSource(tables, includeMappedFields, specialCaseUuidCo
                     table: x.table,
                     junctionTable: x.junctionTable,
                     grabMany: x.grabMany,
-                    relations: x.relations,
+                    relations: x.relations
                 };
             }
             return acc;
         }, {});
-        const _mappedFields = includeMappedFields
-            ? await getMappedFields(table)
-            : [];
+        const _mappedFields = includeMappedFields ? await getMappedFields(table) : [];
         const mappedFields = _mappedFields.length === 0
             ? null
             : _mappedFields.reduce((acc, v) => {
@@ -1073,6 +1216,47 @@ async function getArtifactsSource(tables, includeMappedFields, specialCaseUuidCo
             return acc;
         }, {});
         const uniqueFields = await getUniqueColumns(table, specialCaseUuidColumn);
+        let fields = tableMeta.map((t) => {
+            const nullable = t.Null === "YES";
+            const isEnum = t.Type.startsWith("enum");
+            if (isEnum) {
+                const values = getPropertyEnum(t.Type);
+                if (values && nullable) {
+                    values.push(null);
+                }
+                return {
+                    kind: "enum",
+                    values,
+                    name: t.Field,
+                    nullable
+                };
+            }
+            return {
+                kind: "scalar",
+                type: getBaseJSONType(t.Type),
+                name: t.Field,
+                nullable,
+                hasDefaultValue: !!t.Default
+            };
+        });
+        for (let x of _mappedFields) {
+            fields.push({
+                kind: "scalar",
+                type: x.type,
+                name: x.as,
+                nullable: x.nullable,
+                // TODO
+                hasDefaultValue: false
+            });
+        }
+        for (let x of relationInfo) {
+            fields.push({
+                kind: "object",
+                type: x.table,
+                name: x.name,
+                isList: x.grabMany
+            });
+        }
         return {
             table,
             primaryKey,
@@ -1082,6 +1266,7 @@ async function getArtifactsSource(tables, includeMappedFields, specialCaseUuidCo
             uniqueFields,
             dateTimeFields,
             dateTimeFieldsCount: Object.keys(dateTimeFields).length,
+            fields
         };
     }));
     const artifacts = tableMetaList.reduce((acc, x) => {
@@ -1108,7 +1293,7 @@ const getRelationInfo = _.memoize(async function getRelationInfo(table) {
             table: x.referencedTable,
             name,
             relation: x,
-            nullable: x.nullable,
+            nullable: x.nullable
         };
     }));
     const relationsOneToManyDuplicates = (0, getDuplicates_1.getDuplicates)(relationsOneToMany.map((x) => x.referencedTable));
@@ -1131,7 +1316,7 @@ const getRelationInfo = _.memoize(async function getRelationInfo(table) {
             table: x.referencedTable,
             name,
             relation: x,
-            nullable: x.nullable,
+            nullable: x.nullable
         };
     }));
     const relationsManyToMany = (await getJunctionTables()).reduce((acc, x) => {
@@ -1150,7 +1335,7 @@ const getRelationInfo = _.memoize(async function getRelationInfo(table) {
             name: changeCase.camelCase(dataForChildTable.referencedTable) + "List",
             // Ensure parent comes before child
             relations: [dataForParentTable, dataForChildTable],
-            grabMany: true,
+            grabMany: true
         });
         return acc;
     }, []);
@@ -1171,7 +1356,7 @@ async function getJunctionTables() {
             // e.g. junction of Foo, Bar must be FooBar or BarFoo
             [
                 relations[0].referencedTable + relations[1].referencedTable,
-                relations[1].referencedTable + relations[0].referencedTable,
+                relations[1].referencedTable + relations[0].referencedTable
             ].includes(table)) {
             return { table, relations };
         }
@@ -1227,7 +1412,7 @@ const getRelationsManyToOne = _.memoize(async function getRelationsManyToOne(tab
             foreignKey: v.t1Field,
             referencedTable: v.t2,
             referencedKey: v.t2Field,
-            nullable: tableMeta.find((m) => m.Field === v.t1Field)?.Null === "YES",
+            nullable: tableMeta.find((m) => m.Field === v.t1Field)?.Null === "YES"
         };
     })));
     return _.sortBy((x) => x.referencedTable, xs);
@@ -1276,7 +1461,7 @@ const getRelationsOneToMany = _.memoize(async function getRelationsOneToMany(tab
             referencedTable: v.t1,
             referencedKey: v.t1Field,
             // TODO? I think this is right, since it's one-to-many, so a list
-            nullable: false,
+            nullable: false
         };
     })));
     return _.sortBy((x) => x.referencedKey, _.sortBy((x) => x.referencedTable, xs));
@@ -1291,7 +1476,7 @@ async function getPrimaryColumn(table) {
     return {
         name: column.Field,
         type: getBaseJSONType(column.Type),
-        nullable: column.Null === "YES",
+        nullable: column.Null === "YES"
     };
 }
 async function getUniqueColumns(table, specialCaseUuidColumn) {
@@ -1303,7 +1488,7 @@ async function getUniqueColumns(table, specialCaseUuidColumn) {
         .map((x) => ({
         name: x.Field,
         type: getBaseJSONType(x.Type),
-        nullable: x.Null === "YES",
+        nullable: x.Null === "YES"
     }));
 }
 async function getUuidColumn(table) {
@@ -1315,7 +1500,7 @@ async function getUuidColumn(table) {
     return {
         name: column.Field,
         type: column.Type,
-        nullable: column.Null === "YES",
+        nullable: column.Null === "YES"
     };
 }
 const getTableMeta = _.memoize(async function getTableMeta(table) {
@@ -1359,7 +1544,7 @@ const getTableMeta = _.memoize(async function getTableMeta(table) {
                         ? "UNI"
                         : "",
                 Null: x["IS_NULLABLE"],
-                Default: x["COLUMN_DEFAULT"],
+                Default: x["COLUMN_DEFAULT"]
             };
         })));
     }
@@ -1378,7 +1563,7 @@ function getJSONSchemaObjProperties(tableMeta) {
             _enum.push(null);
         }
         acc[m.Field] = {
-            type: getJSONTypes(baseType, nullable),
+            type: getJSONTypes(baseType, nullable)
             // maxLength:
             //   baseType === "string" && format == null && isEnum == null
             //     ? getPropertyMaxLength(m.Type)
@@ -1488,9 +1673,7 @@ function getPropertyEnum(sqlType) {
     return c;
 }
 function getPropertyFormat(sqlType) {
-    if (sqlType === "datetime" ||
-        sqlType === "datetime2" ||
-        sqlType === "timestamp") {
+    if (sqlType === "datetime" || sqlType === "datetime2" || sqlType === "timestamp") {
         // TODO: not sure this is correct for `timestamp`
         return "date-time";
     }
@@ -1514,7 +1697,7 @@ const mssqlTableExcludes = new Set([
     "ddl_history",
     "index_columns",
     "lsn_time_mapping",
-    "systranschemas",
+    "systranschemas"
 ]);
 async function getTableNames() {
     if (dialect === "mysql") {