@cerebruminc/yates 3.3.0 → 3.3.1-beta.dangerous.402403c

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [3.3.2](https://github.com/cerebruminc/yates/compare/v3.3.1...v3.3.2) (2024-02-28)
+
+
+### Bug Fixes
+
+* do not include test files in published build output ([8bc00dc](https://github.com/cerebruminc/yates/commit/8bc00dc6028df539b8170724757623a8359bd51d))
+
+## [3.3.1](https://github.com/cerebruminc/yates/compare/v3.3.0...v3.3.1) (2024-02-28)
+
+
+### Bug Fixes
+
+* make sure the dist directory is published to npm ([043cba5](https://github.com/cerebruminc/yates/commit/043cba57f9698fb91868dc439de2eb4e54d613b6))
+
 ## [3.3.0](https://github.com/cerebruminc/yates/compare/v3.2.0...v3.3.0) (2024-02-26)
 
 

package/dist/ast-fragments.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Generates an AST fragment that will check if a column value exists in a JSONB array stored in a `current_setting`
+ * The AST fragment represents SQL that looks like this:
+ *  = ANY (SELECT jsonb_array_elements_text(current_setting('ctx.my_context_value')::jsonb))
+ */
+export declare const jsonb_array_elements_text: (setting: string) => {
+    type: string;
+    name: string;
+    args: {
+        type: string;
+        value: {
+            ast: {
+                with: null;
+                type: string;
+                options: null;
+                distinct: {
+                    type: null;
+                };
+                columns: {
+                    type: string;
+                    expr: {
+                        type: string;
+                        name: string;
+                        args: {
+                            type: string;
+                            value: {
+                                type: string;
+                                keyword: string;
+                                expr: {
+                                    type: string;
+                                    name: string;
+                                    args: {
+                                        type: string;
+                                        value: {
+                                            type: string;
+                                            value: string;
+                                        }[];
+                                    };
+                                };
+                                as: null;
+                                symbol: string;
+                                target: {
+                                    dataType: string;
+                                };
+                                arrows: never[];
+                                properties: never[];
+                            }[];
+                        };
+                    };
+                    as: null;
+                }[];
+                into: {
+                    position: null;
+                };
+                from: null;
+                where: null;
+                groupby: null;
+                having: null;
+                orderby: null;
+                limit: {
+                    seperator: string;
+                    value: never[];
+                };
+                window: null;
+            };
+        }[];
+    };
+};

package/dist/ast-fragments.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonb_array_elements_text = void 0;
+var escape_1 = require("./escape");
+/**
+ * Generates an AST fragment that will check if a column value exists in a JSONB array stored in a `current_setting`
+ * The AST fragment represents SQL that looks like this:
+ *  = ANY (SELECT jsonb_array_elements_text(current_setting('ctx.my_context_value')::jsonb))
+ */
+var jsonb_array_elements_text = function (setting) {
+    return {
+        type: "function",
+        name: "ANY",
+        args: {
+            type: "expr_list",
+            value: [
+                {
+                    ast: {
+                        with: null,
+                        type: "select",
+                        options: null,
+                        distinct: {
+                            type: null,
+                        },
+                        columns: [
+                            {
+                                type: "expr",
+                                expr: {
+                                    type: "function",
+                                    name: "jsonb_array_elements_text",
+                                    args: {
+                                        type: "expr_list",
+                                        value: [
+                                            {
+                                                type: "cast",
+                                                keyword: "cast",
+                                                expr: {
+                                                    type: "function",
+                                                    name: "current_setting",
+                                                    args: {
+                                                        type: "expr_list",
+                                                        value: [
+                                                            {
+                                                                type: "parameter",
+                                                                value: (0, escape_1.escapeLiteral)(setting.replace(/^___yates_context_/, "")),
+                                                            },
+                                                        ],
+                                                    },
+                                                },
+                                                as: null,
+                                                symbol: "::",
+                                                target: {
+                                                    dataType: "jsonb",
+                                                },
+                                                arrows: [],
+                                                properties: [],
+                                            },
+                                        ],
+                                    },
+                                },
+                                as: null,
+                            },
+                        ],
+                        into: {
+                            position: null,
+                        },
+                        from: null,
+                        where: null,
+                        groupby: null,
+                        having: null,
+                        orderby: null,
+                        limit: {
+                            seperator: "",
+                            value: [],
+                        },
+                        window: null,
+                    },
+                },
+            ],
+        },
+    };
+};
+exports.jsonb_array_elements_text = jsonb_array_elements_text;
+//# sourceMappingURL=ast-fragments.js.map

package/dist/ast-fragments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-fragments.js","sourceRoot":"","sources":["../src/ast-fragments.ts"],"names":[],"mappings":";;;AAAA,mCAAyC;AAEzC;;;;GAIG;AACI,IAAM,yBAAyB,GAAG,UAAC,OAAe;IACxD,OAAO;QACN,IAAI,EAAE,UAAU;QAChB,IAAI,EAAE,KAAK;QACX,IAAI,EAAE;YACL,IAAI,EAAE,WAAW;YACjB,KAAK,EAAE;gBACN;oBACC,GAAG,EAAE;wBACJ,IAAI,EAAE,IAAI;wBACV,IAAI,EAAE,QAAQ;wBACd,OAAO,EAAE,IAAI;wBACb,QAAQ,EAAE;4BACT,IAAI,EAAE,IAAI;yBACV;wBACD,OAAO,EAAE;4BACR;gCACC,IAAI,EAAE,MAAM;gCACZ,IAAI,EAAE;oCACL,IAAI,EAAE,UAAU;oCAChB,IAAI,EAAE,2BAA2B;oCACjC,IAAI,EAAE;wCACL,IAAI,EAAE,WAAW;wCACjB,KAAK,EAAE;4CACN;gDACC,IAAI,EAAE,MAAM;gDACZ,OAAO,EAAE,MAAM;gDACf,IAAI,EAAE;oDACL,IAAI,EAAE,UAAU;oDAChB,IAAI,EAAE,iBAAiB;oDACvB,IAAI,EAAE;wDACL,IAAI,EAAE,WAAW;wDACjB,KAAK,EAAE;4DACN;gEACC,IAAI,EAAE,WAAW;gEACjB,KAAK,EAAE,IAAA,sBAAa,EAAC,OAAO,CAAC,OAAO,CAAC,oBAAoB,EAAE,EAAE,CAAC,CAAC;6DAC/D;yDACD;qDACD;iDACD;gDACD,EAAE,EAAE,IAAI;gDACR,MAAM,EAAE,IAAI;gDACZ,MAAM,EAAE;oDACP,QAAQ,EAAE,OAAO;iDACjB;gDACD,MAAM,EAAE,EAAE;gDACV,UAAU,EAAE,EAAE;6CACd;yCACD;qCACD;iCACD;gCACD,EAAE,EAAE,IAAI;6BACR;yBACD;wBACD,IAAI,EAAE;4BACL,QAAQ,EAAE,IAAI;yBACd;wBACD,IAAI,EAAE,IAAI;wBACV,KAAK,EAAE,IAAI;wBACX,OAAO,EAAE,IAAI;wBACb,MAAM,EAAE,IAAI;wBACZ,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE;4BACN,SAAS,EAAE,EAAE;4BACb,KAAK,EAAE,EAAE;yBACT;wBACD,MAAM,EAAE,IAAI;qBACZ;iBACD;aACD;SACD;KACD,CAAC;AACH,CAAC,CAAC;AAxEW,QAAA,yBAAyB,6BAwEpC"}

package/dist/escape.d.ts

@@ -0,0 +1,2 @@
+export declare const escapeIdentifier: (str: string) => string;
+export declare const escapeLiteral: (str: string) => string;

package/dist/escape.js

@@ -0,0 +1,36 @@
+"use strict";
+// Source borrowed from node-postgrs (which borrows from PG itself)
+// https://github.com/brianc/node-postgres/blob/3f6760c62ee2a901d374b5e50c2f025b7d550315/packages/pg/lib/client.js#L408-L437
+// We need to manually escape strings because we're interpolating client values into SQL statements that don't support `PREPARE`, such as `CREATE POLICY`
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeLiteral = exports.escapeIdentifier = void 0;
+// Ported from PostgreSQL 9.2.4 source code in src/interfaces/libpq/fe-exec.c
+var escapeIdentifier = function (str) {
+    return "\"".concat(str.replace(/"/g, '""'), "\"");
+};
+exports.escapeIdentifier = escapeIdentifier;
+// Ported from PostgreSQL 9.2.4 source code in src/interfaces/libpq/fe-exec.c
+var escapeLiteral = function (str) {
+    var hasBackslash = false;
+    var escaped = "'";
+    for (var i = 0; i < str.length; i++) {
+        var c = str[i];
+        if (c === "'") {
+            escaped += c + c;
+        }
+        else if (c === "\\") {
+            escaped += c + c;
+            hasBackslash = true;
+        }
+        else {
+            escaped += c;
+        }
+    }
+    escaped += "'";
+    if (hasBackslash === true) {
+        escaped = " E".concat(escaped);
+    }
+    return escaped;
+};
+exports.escapeLiteral = escapeLiteral;
+//# sourceMappingURL=escape.js.map

package/dist/escape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"escape.js","sourceRoot":"","sources":["../src/escape.ts"],"names":[],"mappings":";AAAA,mEAAmE;AACnE,4HAA4H;AAC5H,yJAAyJ;;;AAEzJ,6EAA6E;AACtE,IAAM,gBAAgB,GAAG,UAAU,GAAW;IACpD,OAAO,YAAI,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,OAAG,CAAC;AACvC,CAAC,CAAC;AAFW,QAAA,gBAAgB,oBAE3B;AAEF,6EAA6E;AACtE,IAAM,aAAa,GAAG,UAAU,GAAW;IACjD,IAAI,YAAY,GAAG,KAAK,CAAC;IACzB,IAAI,OAAO,GAAG,GAAG,CAAC;IAElB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;QACf,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;YACf,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;QAClB,CAAC;aAAM,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;YACvB,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;YACjB,YAAY,GAAG,IAAI,CAAC;QACrB,CAAC;aAAM,CAAC;YACP,OAAO,IAAI,CAAC,CAAC;QACd,CAAC;IACF,CAAC;IAED,OAAO,IAAI,GAAG,CAAC;IAEf,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;QAC3B,OAAO,GAAG,YAAK,OAAO,CAAE,CAAC;IAC1B,CAAC;IAED,OAAO,OAAO,CAAC;AAChB,CAAC,CAAC;AAvBW,QAAA,aAAa,iBAuBxB"}

package/dist/expressions.d.ts

@@ -0,0 +1,11 @@
+import { Prisma, PrismaClient } from "@prisma/client";
+import { AsyncReturnType } from "type-fest";
+import { defineDmmfProperty } from "@prisma/client/runtime/library";
+export type RuntimeDataModel = Parameters<typeof defineDmmfProperty>[1];
+type FFMeta<M extends Prisma.ModelName> = PrismaClient[Uncapitalize<M>]["findFirst"];
+type ModelWhereArgs<M extends Prisma.ModelName> = Exclude<Parameters<FFMeta<M>>["0"], undefined>["where"];
+type ModelResult<M extends Prisma.ModelName> = AsyncReturnType<FFMeta<M>>;
+type NonNullableModelResult<M extends Prisma.ModelName> = Exclude<ModelResult<M>, null>;
+export type Expression<ContextKeys extends string, M extends Prisma.ModelName> = string | ((client: PrismaClient, row: <K extends keyof NonNullableModelResult<M>>(col: K) => NonNullableModelResult<M>[K], context: (key: ContextKeys) => string) => Promise<ModelResult<Exclude<Prisma.ModelName, M>>> | ModelWhereArgs<M>);
+export declare const expressionToSQL: <ContextKeys extends string, YModel extends Prisma.ModelName>(getExpression: Expression<ContextKeys, YModel>, table: string) => Promise<string>;
+export {};

package/dist/expressions.js

@@ -0,0 +1,431 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expressionToSQL = void 0;
+var client_1 = require("@prisma/client");
+var random_1 = __importDefault(require("lodash/random"));
+var matches_1 = __importDefault(require("lodash/matches"));
+var node_sql_parser_1 = require("node-sql-parser");
+var escape_1 = require("./escape");
+var ast_fragments_1 = require("./ast-fragments");
+var PRISMA_NUMERIC_TYPES = ["Int", "BigInt", "Float", "Decimal"];
+var deepFind = function (obj, subObj) {
+    var matcher = (0, matches_1.default)(subObj);
+    for (var key in obj) {
+        if (matcher(obj[key])) {
+            return obj[key];
+        }
+        else if (typeof obj[key] === "object") {
+            var result = deepFind(obj[key], subObj);
+            if (result) {
+                return result;
+            }
+        }
+    }
+};
+var expressionRowName = function (col) { return "___yates_row_".concat(col); };
+var expressionContext = function (context) { return "___yates_context_".concat(context); };
+// Generate a big 32bit signed integer to use as an ID
+var getLargeRandomInt = function () { return (0, random_1.default)(1000000000, 2147483647); };
+var getDmmfMetaData = function (client, model, field) {
+    var runtimeDataModel = client._runtimeDataModel;
+    var modelData = runtimeDataModel.models[model];
+    if (!modelData) {
+        throw new Error("Could not retrieve model data from Prisma Client for model '".concat(model, "'"));
+    }
+    var fieldData = modelData.fields.find(function (f) { return f.name === field; });
+    if (!fieldData) {
+        throw new Error("Could not retrieve field data from Prisma Client for field '".concat(model, ".").concat(field, "'"));
+    }
+    return fieldData;
+};
+// Perform substitution of Ints so that Prisma doesn't throw an error due to mismatched type values
+// After we've captured the SQL, we can replace the Ints with the original values
+// The returned tokens are a map of the token int, and the AST fragment that will replace it.
+// We can then reconstruct the query using the AST fragments.
+var tokenizeWhereExpression = function (
+/** The Prisma client to use for metadata */
+client, 
+/** The Prisma where expression to be tokenized */
+where, 
+/** The base table we are generating an expression for */
+table, 
+/** The model name being queried. e.g. 'User' */
+model, 
+/** The tokens object to add the new tokens to */
+tokens) {
+    var e_1, _a;
+    if (tokens === void 0) { tokens = {}; }
+    for (var field in where) {
+        // Get field data from the prisma client for the model and field being queried
+        var fieldData = getDmmfMetaData(client, model, field);
+        var int = void 0;
+        // Small loop to make sure we get a unique int for the token key
+        do {
+            int = getLargeRandomInt();
+        } while (tokens[int]);
+        var astFragment = {};
+        var value = where[field];
+        // Check if the field is an object, if so, we need to recurse
+        // This is a fairly simple approach but covers most cases like "some", "every", "none" etc.
+        if (fieldData.kind === "object") {
+            // List queries will always have a sub-object of "every", "some" or "none", so we need to dropdown and iterate through them
+            if (fieldData.isList) {
+                for (var subField in value) {
+                    var subValue = value[subField];
+                    var _b = tokenizeWhereExpression(client, subValue, table, fieldData.type, tokens), subTokens = _b.tokens, subWhere = _b.where;
+                    tokens = __assign(__assign({}, tokens), subTokens);
+                    where[field][subField] = subWhere;
+                }
+                continue;
+            }
+            else {
+                var _c = tokenizeWhereExpression(client, value, table, fieldData.type, tokens), subTokens = _c.tokens, subWhere = _c.where;
+                tokens = __assign(__assign({}, tokens), subTokens);
+                where[field] = subWhere;
+                continue;
+            }
+        }
+        var isNumeric = PRISMA_NUMERIC_TYPES.includes(fieldData.type);
+        var isColumnName = typeof value === "string" && !!value.match(/^___yates_row_/);
+        var isContext = typeof value === "string" && !!value.match(/^___yates_context_/);
+        var isInStatement = !!value.in;
+        switch (true) {
+            case isColumnName:
+                // Substiture the yates row placeholder for the actual column name
+                var column = value.replace(/^___yates_row_/, "");
+                if (!getDmmfMetaData(client, table, column)) {
+                    throw new Error("Invalid field name \"".concat(column, "\""));
+                }
+                astFragment = {
+                    type: "column_ref",
+                    schema: "public",
+                    table: table,
+                    column: column,
+                };
+                break;
+            case isContext && isNumeric:
+                astFragment = {
+                    as: null,
+                    type: "cast",
+                    expr: {
+                        type: "function",
+                        name: "current_setting",
+                        args: {
+                            type: "expr_list",
+                            value: [
+                                {
+                                    type: "parameter",
+                                    value: (0, escape_1.escapeLiteral)(value.replace(/^___yates_context_/, "")),
+                                },
+                            ],
+                        },
+                    },
+                    symbol: "::",
+                    target: {
+                        dataType: "float",
+                        suffix: [],
+                    },
+                };
+                break;
+            case isContext && !isNumeric:
+                astFragment = {
+                    type: "function",
+                    name: "current_setting",
+                    args: {
+                        type: "expr_list",
+                        value: [
+                            {
+                                type: "parameter",
+                                value: (0, escape_1.escapeLiteral)(value.replace(/^___yates_context_/, "")),
+                            },
+                        ],
+                    },
+                };
+                break;
+            case isNumeric:
+                if (typeof value !== "number") {
+                    throw new Error("Numeric fields can only be queried with numbers: querying field '".concat(field, "' with value '").concat(value, "'"));
+                }
+                astFragment = {
+                    type: "number",
+                    value: value,
+                };
+                break;
+            case isInStatement:
+                // This is a bit hokey, but we are going to assume that each value here is static, and
+                // perform tokenization on each value in the `in` array.
+                // The ideal solution is to rework this tokenization function so that it recurses until it
+                // finds a scalar value, and then tokenizes that value, with checking for row/context values.
+                if (Array.isArray(value.in)) {
+                    var tokenList = [];
+                    try {
+                        for (var _d = (e_1 = void 0, __values(value.in)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                            var item = _e.value;
+                            var inToken = void 0;
+                            do {
+                                inToken = getLargeRandomInt();
+                            } while (tokens[int]);
+                            tokens[inToken] = {
+                                astFragment: {
+                                    type: "parameter",
+                                    value: (0, escape_1.escapeLiteral)(item),
+                                },
+                            };
+                            tokenList.push(isNumeric ? inToken : "".concat(inToken));
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    where[field] = {
+                        in: tokenList,
+                    };
+                    continue;
+                }
+                else {
+                    // If the value of `in` is a context value, we assume that it is an array that has been JSON encoded
+                    // We create an AST fragment representing a function call to `jsonb_array_elements_text` with the context value as the argument
+                    astFragment = (0, ast_fragments_1.jsonb_array_elements_text)(value.in);
+                }
+                break;
+            // All other types are treated as strings
+            default:
+                astFragment = {
+                    type: "parameter",
+                    value: (0, escape_1.escapeLiteral)(value),
+                };
+                break;
+        }
+        tokens[int] = {
+            astFragment: astFragment,
+        };
+        where[field] = isNumeric ? int : "".concat(int);
+    }
+    return {
+        tokens: tokens,
+        where: where,
+    };
+};
+var expressionToSQL = function (getExpression, table) { return __awaiter(void 0, void 0, void 0, function () {
+    var baseClient, tokens, expressionClient, sql;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (typeof getExpression === "string") {
+                    return [2 /*return*/, getExpression];
+                }
+                baseClient = new client_1.PrismaClient({
+                    log: [{ level: "query", emit: "event" }],
+                });
+                tokens = {};
+                expressionClient = baseClient.$extends({
+                    name: "expressionClient",
+                    query: {
+                        $allModels: {
+                            $allOperations: function (_a) {
+                                var model = _a.model, operation = _a.operation, args = _a.args, query = _a.query;
+                                // if not findFirst or findUnique
+                                if (operation !== "findFirst" && operation !== "findUnique") {
+                                    throw new Error('Only "findFirst" and "findUnique" are supported in client expressions');
+                                }
+                                if ("where" in args && args.where) {
+                                    var where = tokenizeWhereExpression(baseClient, args.where, table, model, tokens).where;
+                                    args.where = where;
+                                }
+                                return query(args);
+                            },
+                        },
+                    },
+                });
+                return [4 /*yield*/, new Promise(
+                    // rome-ignore lint/suspicious/noAsyncPromiseExecutor: future cleanup
+                    function (resolve, reject) { return __awaiter(void 0, void 0, void 0, function () {
+                        var rawExpression, isSubselect, error_1;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    rawExpression = getExpression(expressionClient, expressionRowName, expressionContext);
+                                    isSubselect = typeof rawExpression === "object" &&
+                                        "then" in rawExpression &&
+                                        typeof rawExpression.then === "function";
+                                    baseClient.$on("query", function (e) {
+                                        var e_2, _a, e_3, _b;
+                                        try {
+                                            var parser = new node_sql_parser_1.Parser();
+                                            // Parse the query into an AST
+                                            var ast = parser.astify(e.query, {
+                                                database: "postgresql",
+                                            });
+                                            var params = JSON.parse(e.params);
+                                            // By default Prisma will use a parameter for the limit, for Yates, the value is always "1"
+                                            ast.limit = { seperator: "", value: [{ type: "number", value: 1 }] };
+                                            // Now that the SQL has been generated, we can replace the tokens with the original values
+                                            for (var i = 0; i < params.length; i++) {
+                                                var param = params[i];
+                                                var token = tokens[param];
+                                                // If there is no token, we can skip this. The most likely cause of this is that the parameter is for a limit or offset, which we cull from the SQL anyway
+                                                if (!token) {
+                                                    continue;
+                                                }
+                                                var parameterizedStatement = deepFind(ast, {
+                                                    type: "var",
+                                                    name: i + 1,
+                                                    prefix: "$",
+                                                });
+                                                // If we found a matching parameterized statement, we can replace it with the AST fragment.
+                                                // This will replace the parameter with the original value.
+                                                // We do this by mutating the object returned from the deepfind function.
+                                                if (parameterizedStatement) {
+                                                    try {
+                                                        // First, scrub all the keys from the parameterized statement
+                                                        for (var _c = (e_2 = void 0, __values(Object.keys(parameterizedStatement))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                                            var key = _d.value;
+                                                            Reflect.deleteProperty(parameterizedStatement, key);
+                                                        }
+                                                    }
+                                                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                                    finally {
+                                                        try {
+                                                            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                                                        }
+                                                        finally { if (e_2) throw e_2.error; }
+                                                    }
+                                                    try {
+                                                        // Second, add all the keys from the AST fragment to the parameterized statement
+                                                        for (var _e = (e_3 = void 0, __values(Object.keys(token.astFragment))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                                            var key = _f.value;
+                                                            parameterizedStatement[key] = token.astFragment[key];
+                                                        }
+                                                    }
+                                                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                                                    finally {
+                                                        try {
+                                                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                                                        }
+                                                        finally { if (e_3) throw e_3.error; }
+                                                    }
+                                                }
+                                            }
+                                            if (isSubselect) {
+                                                // For subselects, we need to convert the entire query and wrap in EXISTS so it converts to a binary expression
+                                                var subSelect = parser.sqlify(ast, {
+                                                    database: "postgresql",
+                                                });
+                                                resolve("EXISTS(".concat(subSelect, ")"));
+                                            }
+                                            else {
+                                                // For basic expressions, we're only interested in the WHERE clause and can convert just the WHERE clause into SQL
+                                                var where = parser.exprToSQL(ast.where, {
+                                                    database: "postgresql",
+                                                });
+                                                resolve(where);
+                                            }
+                                        }
+                                        catch (error) {
+                                            reject(error);
+                                        }
+                                    });
+                                    _a.label = 1;
+                                case 1:
+                                    _a.trys.push([1, 6, , 7]);
+                                    if (!isSubselect) return [3 /*break*/, 3];
+                                    return [4 /*yield*/, rawExpression];
+                                case 2:
+                                    _a.sent();
+                                    return [3 /*break*/, 5];
+                                case 3: return [4 /*yield*/, expressionClient[table].findFirst({
+                                        where: rawExpression,
+                                    })];
+                                case 4:
+                                    _a.sent();
+                                    _a.label = 5;
+                                case 5: return [3 /*break*/, 7];
+                                case 6:
+                                    error_1 = _a.sent();
+                                    reject(error_1);
+                                    return [3 /*break*/, 7];
+                                case 7: return [2 /*return*/];
+                            }
+                        });
+                    }); })];
+            case 1:
+                sql = _a.sent();
+                // Close the client
+                return [4 /*yield*/, expressionClient.$disconnect()];
+            case 2:
+                // Close the client
+                _a.sent();
+                return [4 /*yield*/, baseClient.$disconnect()];
+            case 3:
+                _a.sent();
+                return [2 /*return*/, sql];
+        }
+    });
+}); };
+exports.expressionToSQL = expressionToSQL;
+//# sourceMappingURL=expressions.js.map