@cerebruminc/yates 3.8.1-beta.dangerous.df7fdbd → 3.8.1

package/dist/expressions.js

@@ -1,3 +1,441 @@
 "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 debug_1 = __importDefault(require("debug"));
+var matches_1 = __importDefault(require("lodash/matches"));
+var random_1 = __importDefault(require("lodash/random"));
+var node_sql_parser_1 = require("node-sql-parser");
+var ast_fragments_1 = require("./ast-fragments");
+var escape_1 = require("./escape");
+var debug = (0, debug_1.default)("yates");
+var PRISMA_NUMERIC_TYPES = ["Int", "BigInt", "Float", "Decimal"];
+// This function is a recursive function that will search through an object and
+// its children to find a matching object.
+// It's used to find a matching AST fragment so that we can replace it with a token
+// TODO future cleanup
+var deepFind = function (obj, subObj) {
+    var matcher = (0, matches_1.default)(subObj);
+    for (var key in obj) {
+        if (matcher(obj[key])) {
+            return obj[key];
+        }
+        if (typeof obj[key] === "object") {
+            var result = deepFind(obj[key], subObj);
+            if (result) {
+                return result;
+            }
+        }
+    }
+};
+// TODO fix this
+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_1 = _b.tokens, subWhere_1 = _b.where;
+                    // biome-ignore lint/style/noParameterAssign: TODO fix this
+                    tokens = __assign(__assign({}, tokens), subTokens_1);
+                    where[field][subField] = subWhere_1;
+                }
+                continue;
+            }
+            var _c = tokenizeWhereExpression(client, value, table, fieldData.type, tokens), subTokens = _c.tokens, subWhere = _c.where;
+            // biome-ignore lint/style/noParameterAssign: TODO fix this
+            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
+                // biome-ignore lint/correctness/noSwitchDeclarations: TODO fix this
+                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;
+                            // biome-ignore lint/suspicious/noImplicitAnyLet: TODO fix this
+                            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;
+                }
+                // 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];
+                }
+                debug("Creating RLS expression from", getExpression.toString());
+                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(
+                    // biome-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();
+                debug("Generated RLS expression", sql);
+                return [2 /*return*/, sql];
+        }
+    });
+}); };
+exports.expressionToSQL = expressionToSQL;
 //# sourceMappingURL=expressions.js.map

package/dist/expressions.js.map

@@ -1 +1 @@
-{"version":3,"file":"expressions.js","sourceRoot":"","sources":["../src/expressions.ts"],"names":[],"mappings":""}
+{"version":3,"file":"expressions.js","sourceRoot":"","sources":["../src/expressions.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -3,6 +3,12 @@ import { Expression, RuntimeDataModel } from "./expressions";
 declare const VALID_OPERATIONS: readonly ["SELECT", "UPDATE", "INSERT", "DELETE"];
 type Operation = (typeof VALID_OPERATIONS)[number];
 export type Models = Prisma.ModelName;
+interface ClientOptions {
+    /** The maximum amount of time Yates will wait to acquire a transaction from the database. The default value is 30 seconds. */
+    txMaxWait?: number;
+    /** The maximum amount of time the Yates query transaction can run before being canceled and rolled back. The default value is 30 seconds. */
+    txTimeout?: number;
+}
 export interface Ability<ContextKeys extends string, M extends Models> {
     description?: string;
     expression?: Expression<ContextKeys, M>;
@@ -26,10 +32,16 @@ export type CustomAbilities<ContextKeys extends string = string, YModels extends
 };
 export type GetContextFn<ContextKeys extends string = string> = () => {
     role: string;
+    transactionId?: string;
     context?: {
         [key in ContextKeys]: string | number | string[];
     };
 } | null;
+declare module "@prisma/client" {
+    interface PrismaClient {
+        _executeRequest: (params: any) => Promise<any>;
+    }
+}
 export interface SetupParams<ContextKeys extends string = string, YModels extends Models = Models, K extends CustomAbilities<ContextKeys, YModels> = CustomAbilities<ContextKeys, YModels>> {
     /**
      * The Prisma client instance. Used for database queries and model introspection.
@@ -49,26 +61,57 @@ export interface SetupParams<ContextKeys extends string = string, YModels extend
     /**
      * A function that returns the context for the current request.
      * This is called on every prisma query, and is needed to determine the current user's role.
+     * You can also provide additional context here, which will be available in any RLS expressions you've defined.
      * Returning `null` will result in the permissions being skipped entirely.
      */
     getContext: GetContextFn<ContextKeys>;
+    options?: ClientOptions;
 }
 export declare const sanitizeSlug: (slug: string) => string;
 export declare class Yates {
     private prisma;
+    private databaseScope;
     constructor(prisma: PrismaClient);
-    inspectRunTimeDataModel: () => RuntimeDataModel;
+    init: () => Promise<void>;
+    createDatabaseScope: (databaseName: string) => string;
+    getDatabaseScope: () => string;
+    ensureDatabaseScope: () => Promise<string>;
+    setupAbilityTable: () => Promise<[number, number, number]>;
+    createAbilityName: (model: string, ability: string) => string;
+    createRoleName: (name: string) => string;
     getDefaultAbilities: (models: Models[]) => Partial<DefaultAbilities<string, Prisma.ModelName>>;
+    getBatchId(query: any): string | undefined;
+    buildKeysString(obj: object): string;
+    createClient: (getContext: GetContextFn, options?: ClientOptions) => import("@prisma/client/runtime/library").DynamicClientExtensionThis<Prisma.TypeMap<import("@prisma/client/runtime/library").InternalArgs & {
+        result: {};
+        model: {};
+        query: {};
+        client: {};
+    }>, Prisma.TypeMapCb, {
+        result: {};
+        model: {};
+        query: {};
+        client: {};
+    }>;
+    setRLS: <ContextKeys extends string, YModel extends Prisma.ModelName>(prisma: PrismaClient, table: string, roleName: string, slug: string, ability: Ability<ContextKeys, YModel>) => Promise<void>;
+    createRoles: <ContextKeys extends string, YModels extends Prisma.ModelName, K extends CustomAbilities<string, Prisma.ModelName> = CustomAbilities<string, Prisma.ModelName>, T = DefaultAbilities<ContextKeys, YModels> & K>({ customAbilities, getRoles, }: {
+        customAbilities?: Partial<K> | undefined;
+        getRoles: (abilities: T) => {
+            [role: string]: "*" | AllAbilities<ContextKeys, YModels>[];
+        };
+    }) => Promise<void>;
+    inspectDBRoles: (role: string) => Promise<{
+        tablename: string;
+        policyname: string;
+        cmd: string;
+        policy_roles: string[];
+        matched_role: string[];
+    }[]>;
+    inspectRunTimeDataModel: () => RuntimeDataModel;
 }
 /**
- * Creates an extended client that applies role abilities to Prisma queries.
+ * Creates an extended client that sets contextual parameters and user role on every query
  **/
-export declare const __private: {
-    denyWhere: (runtimeDataModel: RuntimeDataModel, model: string) => Record<string, any>;
-    getIdField: (runtimeDataModel: RuntimeDataModel, model: string) => string | null;
-    matchesScalarFilter: (value: any, filter: any, data: Record<string, any>) => boolean;
-    validateContext: (context: Record<string, any> | undefined) => void;
-};
 export declare const setup: <ContextKeys extends string = string, YModels extends Prisma.ModelName = Prisma.ModelName, K extends CustomAbilities<ContextKeys, YModels> = CustomAbilities<ContextKeys, YModels>>(params: SetupParams<ContextKeys, YModels, K>) => Promise<import("@prisma/client/runtime/library").DynamicClientExtensionThis<Prisma.TypeMap<import("@prisma/client/runtime/library").InternalArgs & {
     result: {};
     model: {};