@technicity/data-service-generator 0.2.8 → 0.4.1

package/dist/CustomError.d.ts

@@ -0,0 +1,3 @@
+export declare class CustomError extends Error {
+    constructor(message: string);
+}

package/dist/SDKNotFoundError.d.ts

@@ -0,0 +1,4 @@
+import { CustomError } from "./CustomError";
+export declare class SDKNotFoundError extends CustomError {
+    constructor();
+}

package/dist/addNullFallbacks.d.ts

@@ -0,0 +1 @@
+export declare function addNullFallbacks(sqlAST: any, data: any): void;

package/dist/addNullFallbacks.js

@@ -4,6 +4,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addNullFallbacks = void 0;
 function addNullFallbacks(sqlAST, data) {
+    if (data == null) {
+        return;
+    }
     for (let child of sqlAST.children ?? []) {
         if (child.type === "table") {
             if (Array.isArray(data)) {

package/dist/cursor.d.ts

@@ -0,0 +1,2 @@
+export declare function encodeCursor(cursor: string): string;
+export declare function decodeCursor(cursor: string): any;

package/dist/generate.d.ts

@@ -0,0 +1,20 @@
+import type { IDialect, ISupplementClientOpts } from "./types";
+declare type ISpecialCaseUuidColumn = boolean;
+declare type IIncludeMappedFields = boolean;
+declare type IGenerateInput = {
+    dialect: IDialect;
+    database: string;
+    user: string;
+    password?: string;
+    host?: string;
+    port?: number;
+    server?: string;
+    outdir: string;
+    tables?: Array<string>;
+    excludeTables?: Array<string>;
+    specialCaseUuidColumn?: ISpecialCaseUuidColumn;
+    includeMappedFields?: IIncludeMappedFields;
+    supplementClientOpts?: ISupplementClientOpts;
+};
+export declare function generate(input: IGenerateInput): Promise<void>;
+export {};

package/dist/generate.js

@@ -32,7 +32,7 @@ async function generate(input) {
     }
     const specialCaseUuidColumn = input.specialCaseUuidColumn ?? true;
     const includeMappedFields = input.includeMappedFields ?? true;
-    const supplementDriverOpts = input.supplementDriverOpts ?? true;
+    const supplementClientOpts = input.supplementClientOpts ?? true;
     dialect = input.dialect;
     init(input);
     let tables = await getTableNames();
@@ -56,7 +56,7 @@ async function generate(input) {
         getDeleteListData(x),
     ]));
     const artifactsSource = await getArtifactsSource(tables, includeMappedFields);
-    const sdkSource = await getSDKSource(data, specialCaseUuidColumn, supplementDriverOpts);
+    const sdkSource = await getSDKSource(data, specialCaseUuidColumn, supplementClientOpts);
     const sdkFilename = "index.ts";
     const artifactsFilename = "artifacts.ts";
     const tsConfigJSON = {
@@ -88,8 +88,7 @@ async function generate(input) {
     fs.writeFileSync(path.join(tmpDirPath, artifactsFilename), artifactsSource);
     const typesDirPath = path.join(tmpDirPath, "types");
     fse.mkdirpSync(typesDirPath);
-    fs.writeFileSync(path.join(typesDirPath, "Paginate.ts"), getTypePaginate());
-    fs.writeFileSync(path.join(typesDirPath, "ListPaginated.ts"), getTypeListPaginated());
+    fs.writeFileSync(path.join(typesDirPath, "_shared.ts"), getTypeShared());
     for (let x of data) {
         if (x.kind === "getOne") {
             fs.writeFileSync(path.join(typesDirPath, x.typeFieldsName + ".ts"), x.typeFields);
@@ -117,10 +116,6 @@ async function generate(input) {
     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 = "));
-    // TODO: workaround for SDKNotFoundError not being imported properly
-    fs.writeFileSync(path.join(tmpBuildOutputPath, "index.d.ts"), fs
-        .readFileSync(path.join(tmpBuildOutputPath, "index.d.ts"), "utf-8")
-        .replace('import { SDKNotFoundError } from "./src/runtime";', '// @ts-ignore\nimport { SDKNotFoundError } from "./src/runtime";'));
     if (!fs.existsSync(outdir)) {
         fse.mkdirpSync(outdir);
     }
@@ -141,7 +136,7 @@ function init(input) {
         });
         query = mysql.query;
     }
-    if (dialect === "mssql") {
+    if (dialect === "mssql" || dialect === "ksql") {
         const pool = new mssql.ConnectionPool({
             server: server ?? "localhost",
             user,
@@ -161,13 +156,12 @@ 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, driverOpts, etc.
-async function getSDKSource(input, specialCaseUuidColumn, supplementDriverOpts) {
+// 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 { init, resolve, post, patch, patchList, del, deleteList, whereNeedsProcessing, _prepareWhere, SDKNotFoundError } from "./src/runtime";
   import { artifacts } from "./artifacts";
-  import type { Paginate } from "./types/Paginate";
-  import type { ListPaginated } from "./types/ListPaginated";
+  import type { Paginate, ListPaginated } from "./types/_shared";
   ${input.reduce((acc, x) => {
         if (x.kind === "getOne") {
             acc += `import type { ${x.typeReturnBaseName} } from "./types/${x.typeReturnBaseName}";`;
@@ -185,40 +179,30 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementDriverOpts)
         }
         return acc;
     }, "")}
-  
-  export { SDKNotFoundError };
-
-  type IDialect = "mysql" | "mssql";
 
   export class SDK {
-    dialect: IDialect;
+    runtime: any;
   
-    constructor(opts: { 
-      dialect: IDialect; 
-      driverOpts: {
-        database: string;
-        user?: string;
-        password?: string;
-        host?: string;
-        port?: string | number;
-        [k: string]: any;
-      }
+    constructor(opts: {
+      runtime: any;
+      clientOpts: { [k: string]: any; },
+      otherOpts?: { [k: string]: any; }
      }) {
-      this.dialect = opts.dialect;
-      init(this.dialect, ${supplementDriverOpts === true
-        ? "{supplementDriverOpts: true, ...opts.driverOpts}"
-        : "opts.driverOpts"});
+      opts.otherOpts = opts.otherOpts ?? {}
+      this.runtime = new opts.runtime(opts.clientOpts, ${supplementClientOpts === true
+        ? "{ supplementClientOpts: true, ...opts.otherOpts }"
+        : "opts.otherOpts"}, artifacts);
     }
 
     __whereNeedsProcessing(where: any) {
-      return whereNeedsProcessing(where);
+      return this.runtime.whereNeedsProcessing(where);
     }
 
     async __prepareWhere(
       table: string,
       where: any
     ) {
-      return _prepareWhere(artifacts, table, where, this.dialect);
+      return this.runtime._prepareWhere(artifacts, table, where);
     }
 
     ${(await Promise.all(input.flatMap(async (x) => {
@@ -239,16 +223,15 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementDriverOpts)
                 .join(" | ")}, 
                 param2?: { fields?: ${x.typeFieldsName}, correlationId?: string }
               ): Promise<${x.typeReturnBaseName}> {
-              return resolve(
+              return this.runtime.resolve(
                 {
                   table: "${x.table}",
                   fieldName: "${x.fieldName}",
                   args: { $where: param1 },
                   fields: param2?.fields,
                   grabMany: false,
-                  artifacts,
-                },
-                { dialect: this.dialect }
+                  artifacts
+                }
               );
             }`;
         }
@@ -257,7 +240,7 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementDriverOpts)
             param1: { $where?: ${x.typeWhereName}, $orderBy?: ${x.typeOrderByName}, $limit?: number }, 
             param2?: { fields?: ${x.typeFieldsName}, correlationId?: string }
           ): Promise<Array<${x.typeReturnBaseName}>> {
-            return resolve(
+            return this.runtime.resolve(
               {
                 table: "${x.table}",
                 fieldName: "${x.fieldName}",
@@ -266,8 +249,7 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementDriverOpts)
                 grabMany: true,
                 artifacts,
                 kind: "list"
-              },
-              { dialect: this.dialect }
+              }
             );
           }`;
         }
@@ -276,7 +258,7 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementDriverOpts)
             param1: { $where?: ${x.typeWhereName}, $orderBy?: ${x.typeOrderByName}, $paginate: Paginate }, 
             param2?: { fields?: ${x.typeFieldsName}, correlationId?: string }
           ): Promise<ListPaginated<${x.typeReturnBaseName}>> {
-            return resolve(
+            return this.runtime.resolve(
               {
                 table: "${x.table}",
                 fieldName: "${x.fieldName}",
@@ -285,8 +267,7 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementDriverOpts)
                 grabMany: true,
                 artifacts,
                 kind: "listPaginated"
-              },
-              { dialect: this.dialect }
+              }
             );
           }`;
         }
@@ -300,23 +281,13 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementDriverOpts)
                 uniqueColumns.find((x) => x.name === "uuid")
                 ? `if (!Object.prototype.hasOwnProperty.call(payload, "uuid")) { payload = {...payload, uuid: uuidv4()} }`
                 : ""}
-          const id = await post({
+          return this.runtime.post({
             table: "${x.table}",
             data: payload,
             artifacts,
-            dialect: this.dialect
+            fieldName: "${x.fieldName}",
+            fields: param2?.fields,
           });
-          return resolve(
-            {
-              table: "${x.table}",
-              fieldName: "${x.fieldName}",
-              args: { $where: { id } },
-              fields: param2?.fields,
-              grabMany: false,
-              artifacts,
-            },
-            { dialect: this.dialect }
-          );
         }`;
         }
         if (x.kind === "patchOne") {
@@ -327,24 +298,14 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementDriverOpts)
             data: ${x.typeDataName}, 
             param2?: { fields?: ${x.typeFieldsName}, correlationId?: string }
           ): Promise<${x.typeReturnBaseName}> {
-          await patch({
+          return this.runtime.patch({
             table: "${x.table}",
-            findOne: param1,
+            args: { $where: param1 },
             data,
             artifacts,
-            dialect: this.dialect
+            fieldName: "${x.fieldName}",
+            fields: param2?.fields,
           });
-          return resolve(
-            {
-              table: "${x.table}",
-              fieldName: "${x.fieldName}",
-              args: { $where: param1 },
-              fields: param2?.fields,
-              grabMany: false,
-              artifacts,
-            },
-            { dialect: this.dialect }
-          );
         }`;
         }
         if (x.kind === "patchList") {
@@ -353,25 +314,14 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementDriverOpts)
             data: ${x.typeDataName}, 
             param2?: { fields?: ${x.typeFieldsName}, correlationId?: string }
           ): Promise<Array<${x.typeReturnBaseName}>> {
-          await patchList({
+          return this.runtime.patchList({
             table: "${x.table}",
-            where: param1.$where,
+            args: param1,
             data,
             artifacts,
-            dialect: this.dialect
+            fieldName: "${x.fieldName}",
+            fields: param2?.fields,
           });
-          return resolve(
-            {
-              table: "${x.table}",
-              fieldName: "${x.fieldName}",
-              args: param1,
-              fields: param2?.fields,
-              grabMany: true,
-              artifacts,
-              kind: "list"
-            },
-            { dialect: this.dialect }
-          );
         }`;
         }
         if (x.kind === "deleteOne") {
@@ -381,10 +331,9 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementDriverOpts)
                 .join(" | ")},
             param2?: { correlationId?: string }
           ): Promise<void> {
-            await del({
+            await this.runtime.del({
               table: "${x.table}",
-              findOne: param1,
-              dialect: this.dialect
+              args: { $where: param1 },
             });
           }`;
         }
@@ -393,11 +342,10 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementDriverOpts)
             param1: { $where?: ${x.typeWhereName} },
             param2?: { correlationId?: string }
           ): Promise<void> {
-            await deleteList({
+            await this.runtime.deleteList({
               table: "${x.table}",
-              where: param1.$where,
-              artifacts,
-              dialect: this.dialect
+              args: param1,
+              artifacts
             });
           }`;
         }
@@ -590,6 +538,23 @@ async function getTypeDataPatch(table, name, specialCaseUuidColumn, includeMappe
         }
     }
     let properties = getJSONSchemaObjProperties(tableMeta);
+    let mustImportTUpdateOperationsString = false;
+    let mustImportTUpdateOperationsNumber = false;
+    for (let key in properties) {
+        const type = unwrapJSONType(properties[key].type);
+        if (type === "string") {
+            properties[key] = {
+                oneOf: [properties[key], { tsType: "TUpdateOperationsString" }],
+            };
+            mustImportTUpdateOperationsString = true;
+        }
+        else if (type === "number" || type === "integer") {
+            properties[key] = {
+                oneOf: [properties[key], { tsType: "TUpdateOperationsNumber" }],
+            };
+            mustImportTUpdateOperationsNumber = true;
+        }
+    }
     if (includeMappedFields) {
         const mappedFields = await getMappedFields(table);
         properties = {
@@ -606,7 +571,28 @@ async function getTypeDataPatch(table, name, specialCaseUuidColumn, includeMappe
         additionalProperties: false,
         required: [],
     };
-    return json_schema_to_typescript_1.compile(jsonSchema, name);
+    let type = await json_schema_to_typescript_1.compile(jsonSchema, name);
+    if (mustImportTUpdateOperationsString || mustImportTUpdateOperationsNumber) {
+        const imports = [];
+        if (mustImportTUpdateOperationsString) {
+            imports.push("TUpdateOperationsString");
+        }
+        if (mustImportTUpdateOperationsNumber) {
+            imports.push("TUpdateOperationsNumber");
+        }
+        const importsStr = imports
+            .map((x) => `import type { ${x} } from "./_shared";`)
+            .join("\n");
+        type = importsStr + "\n\n" + type;
+    }
+    return type;
+}
+function unwrapJSONType(type) {
+    if (Array.isArray(type)) {
+        // Gets first non-null type
+        return type.filter((x) => x !== "null")[0];
+    }
+    return type;
 }
 async function getMappedFields(table) {
     const relationsManyToOne = await getRelationsManyToOne(table).then((xs) => xs.filter((x) => x.foreignKey.endsWith("Id")));
@@ -803,7 +789,7 @@ async function getJSONSchemaOrderBy(table) {
         ],
     };
 }
-function getTypePaginate() {
+function getTypeShared() {
     const src = `export type Paginate = {
     first: number;
     after?: string;
@@ -812,20 +798,23 @@ function getTypePaginate() {
     last: number;
     after?: string;
     before?: string;
-}`;
-    return prettier.format(src, { parser: "typescript" });
 }
-function getTypeListPaginated() {
-    const src = `export type ListPaginated<T> = {
-    paginationInfo: {
-      hasPreviousPage: boolean,
-      hasNextPage: boolean,
-      startCursor: string | number,
-      endCursor: string | number,
-      totalCount: number,
-    },
-    results: Array<T>,
-  }`;
+
+export type ListPaginated<T> = {
+  paginationInfo: {
+    hasPreviousPage: boolean,
+    hasNextPage: boolean,
+    startCursor: string | number,
+    endCursor: string | number,
+    totalCount: number,
+  },
+  results: Array<T>,
+}
+
+export type TUpdateOperationsString = {$prepend: string} | {$append: string}
+
+export type TUpdateOperationsNumber = {$increment: number} | {$decrement: number}
+`;
     return prettier.format(src, { parser: "typescript" });
 }
 async function getTypeFields(table, name, includeMappedFields) {
@@ -1239,7 +1228,7 @@ const getTableMeta = _.memoize(async function getTableMeta(table) {
     if (dialect === "mysql") {
         return query("DESCRIBE ??", [table]).then((xs) => _.sortBy((x) => x.Field, xs));
     }
-    if (dialect === "mssql") {
+    if (dialect === "mssql" || dialect === "ksql") {
         const primaryColumn = await query(`SELECT columns.name as COLUMN_NAME
           FROM sys.tables tables
           JOIN sys.columns columns
@@ -1437,7 +1426,7 @@ async function getTableNames() {
     if (dialect === "mysql") {
         return query("SHOW TABLES").then((xs) => xs.flatMap((x) => Object.values(x)).sort());
     }
-    if (dialect === "mssql") {
+    if (dialect === "mssql" || dialect === "ksql") {
         return query("SELECT * FROM INFORMATION_SCHEMA.TABLES").then((xs) => xs
             .map((x) => x["TABLE_NAME"])
             .filter((x) => !x.startsWith("dbo_") && !mssqlTableExcludes.has(x))

package/dist/getDateTimeStringMySQL.d.ts

@@ -0,0 +1 @@
+export declare function getDateTimeStringMySQL(dateTimeString: string): string;

package/dist/getDuplicates.d.ts

@@ -0,0 +1 @@
+export declare function getDuplicates<T extends any>(arr: Array<T>): any[];

package/dist/getOrderBy.d.ts

@@ -0,0 +1,5 @@
+import { IArgs, IOrderBy } from "./types";
+export declare function getOrderBy(args: IArgs | undefined, primaryKey: string): {
+    orderBy: IOrderBy | undefined;
+    flip: boolean;
+};

package/dist/getOrderBy.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrderBy = void 0;
+// https://gist.github.com/pcattori/2bb645d587e45c9fdbcabf5cef7a7106
+function getOrderBy(args, primaryKey) {
+    let out = undefined;
+    let flip = false;
+    if (Array.isArray(args?.$orderBy)) {
+        out = args?.$orderBy.map((x) => {
+            const [column, direction] = Object.entries(x)[0];
+            return { column, direction };
+        });
+    }
+    else if (typeof args?.$orderBy === "object" && args.$orderBy != null) {
+        const [column, direction] = Object.entries(args.$orderBy)[0];
+        out = [{ column, direction }];
+    }
+    if (args?.$paginate?.first != null || args?.$paginate?.last != null) {
+        // If paginating and primaryKey is not in orderBy, add it to end.
+        // Not necessarily "asc"; see flip.
+        if (!out?.find((x) => x.column === primaryKey)) {
+            const orderByPrimaryKey = { column: primaryKey, direction: "asc" };
+            if (out == null) {
+                out = [orderByPrimaryKey];
+            }
+            else {
+                out = out.concat(orderByPrimaryKey);
+            }
+        }
+        flip = getFlip(args, out, primaryKey);
+        if (flip) {
+            out = flipOrderByDirection(out);
+        }
+    }
+    return { orderBy: out, flip };
+}
+exports.getOrderBy = getOrderBy;
+function getFlip(args, orderBy, primaryKey) {
+    if (args?.$paginate?.first != null &&
+        orderBy?.find((x) => x.column === primaryKey)?.direction === "desc") {
+        return true;
+    }
+    if (args?.$paginate?.last != null &&
+        orderBy?.find((x) => x.column === primaryKey)?.direction === "asc") {
+        return true;
+    }
+    return false;
+}
+function flipOrderByDirection(orderBy) {
+    return orderBy.map((x) => ({ ...x, direction: flipDirection(x.direction) }));
+}
+function flipDirection(direction) {
+    return direction === "asc" ? "desc" : "asc";
+}

package/dist/getSqlAst.d.ts

@@ -0,0 +1,2 @@
+import { IGetSQLASTInput } from "./types";
+export declare function getSqlAst(input: IGetSQLASTInput): any;

package/dist/getSqlAst.js

@@ -7,6 +7,7 @@ const TSqlString = require("tsqlstring");
 // @ts-ignore
 const alias_namespace_1 = require("join-monster/dist/alias-namespace");
 const _ = require("lodash/fp");
+const getOrderBy_1 = require("./getOrderBy");
 const namespace = new alias_namespace_1.default(true);
 function getSqlAst(input) {
     const { table, fieldName, fields, args, grabMany, sqlJoin, sqlBatch, junction, getWhere, artifacts, rowWithCursorId, dialect, } = input;
@@ -15,7 +16,7 @@ function getSqlAst(input) {
     const format = dialect === "mysql"
         ? SqlString.format.bind(SqlString)
         : TSqlString.format.bind(TSqlString);
-    const orderBy = args?.$orderBy == null ? undefined : getOrderBy(args, primaryKey);
+    const orderBy = input.orderBy ?? getOrderBy_1.getOrderBy(args, primaryKey)?.orderBy;
     let where = input.where;
     if (input.where == null) {
         where = (table, args) => {
@@ -24,7 +25,7 @@ function getSqlAst(input) {
                 argsMapped = _.cloneDeep(argsMapped);
                 argsMapped.$where = argsMapped.$where[0];
             }
-            const whereResult = getWhere(table, argsMapped, primaryKey, dialect, orderBy, rowWithCursorId);
+            const whereResult = getWhere(table, argsMapped, dialect, orderBy, rowWithCursorId);
             if (whereResult == null) {
                 return undefined;
             }
@@ -111,7 +112,7 @@ function getSqlAst(input) {
                             }
                             const argsMapped = _.cloneDeep(args);
                             argsMapped.$where = argsMapped.$where[1];
-                            const whereResult = getWhere(table, argsMapped, artifacts[relationField.junctionTable].primaryKey, dialect, orderBy, rowWithCursorId);
+                            const whereResult = getWhere(table, argsMapped, dialect, orderBy, rowWithCursorId);
                             if (whereResult == null) {
                                 return undefined;
                             }
@@ -198,34 +199,3 @@ function columnToASTChild(columnName, namespace, fromOtherTable) {
 function toClumsyName(keyArr) {
     return keyArr.map((name) => name.slice(0, 3)).join("#");
 }
-function getOrderBy(args, primaryKey) {
-    let out = undefined;
-    if (Array.isArray(args.$orderBy)) {
-        out = args.$orderBy.map((x) => {
-            const [column, direction] = Object.entries(x)[0];
-            return { column, direction };
-        });
-    }
-    else {
-        const [column, direction] = Object.entries(args.$orderBy)[0];
-        out = [{ column, direction }];
-    }
-    if (args?.$paginate?.first != null) {
-        out = out
-            .filter((x) => x.column !== primaryKey)
-            // id needs to be last
-            .concat({ column: primaryKey, direction: "asc" });
-    }
-    else if (args?.$paginate?.last != null) {
-        out = out
-            .filter((x) => x.column !== primaryKey)
-            // Need to flip if we're paginating backwards.
-            .map((x) => ({
-            column: x.column,
-            direction: x.direction === "asc" ? "desc" : "asc",
-        }))
-            // id needs to be last
-            .concat({ column: primaryKey, direction: "desc" });
-    }
-    return out;
-}

package/dist/getWhere.d.ts

@@ -0,0 +1,2 @@
+import type { IOrderBy, IDialect } from "./types";
+export declare function getWhere(table: string, args: any, dialect: IDialect, orderBy?: IOrderBy | undefined, rowWithCursorId?: any): string | null;

package/dist/getWhere.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWhere = void 0;
 const stringifyWhere_1 = require("./stringifyWhere");
-function getWhere(table, args, primaryKey, dialect, orderBy, rowWithCursorId) {
+function getWhere(table, args, dialect, orderBy, rowWithCursorId) {
     if (args?.$where == null && args?.$paginate == null) {
         return null;
     }
@@ -13,7 +13,6 @@ function getWhere(table, args, primaryKey, dialect, orderBy, rowWithCursorId) {
         dialect,
         args,
         orderBy,
-        primaryKey,
         rowWithCursorId,
     }) || null);
 }

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/isNotNullOrUndefined.d.ts

@@ -0,0 +1 @@
+export declare function isNotNullOrUndefined<T extends Object>(input: null | undefined | T): input is T;

package/dist/ksql.d.ts

@@ -0,0 +1,9 @@
+export declare class KSQL {
+    hostname: string;
+    port: number;
+    constructor(options: {
+        hostname: string;
+        port: number;
+    });
+    streamQuery(s: string): Promise<any[]>;
+}