prisma-rls - npm Package Compare versions

Comparing version 0.1.3 to 0.1.4

dist/utils.js

@@ -91,3 +91,3 @@ "use strict";
         const relationPermissions = permissionsConfig[relationModelName];
-        if (relationPermissions.read === false) {
+        if (!relationPermissions.read) {
             return { where: (0, exports.generateImpossibleWhere)(fieldsMap[modelName]) };
@@ -132,3 +132,3 @@ }
                     case "create":
-                        if (relationPermissions.create === false) {
+                        if (!relationPermissions.create) {
                             throw new Error("Not authorized");
@@ -142,3 +142,3 @@ }
                     case "createMany":
-                        if (relationPermissions.create === false) {
+                        if (!relationPermissions.create) {
                             throw new Error("Not authorized");
@@ -148,10 +148,10 @@ }
                     case "connectOrCreate":
-                        if (relationPermissions.create === false) {
+                        if (!relationPermissions.create) {
                             throw new Error("Not authorized");
                         }
-                        else if (relationPermissions.read === false) {
+                        else if (!relationPermissions.read) {
                             return transformValue(actionValue, (value) => {
                                 return {
+                                    create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, value.create),
                                     where: (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, value.where, (0, exports.generateImpossibleWhere)(fieldsMap[relationModelName])),
-                                    create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, value),
                                 };
@@ -163,10 +163,17 @@ });
                                 return {
+                                    create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, value.create),
                                     where: (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, value.where, (0, exports.resolveWhere)(relationPermissions.read, context)),
+                                };
+                            });
+                        }
+                        else {
+                            return transformValue(actionValue, (value) => {
+                                return {
                                     create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, value),
+                                    where: value.where,
                                 };
                             });
                         }
-                        break;
                     case "connect":
-                        if (relationPermissions.read === false) {
+                        if (!relationPermissions.read) {
                             return transformValue(actionValue, (value) => {
@@ -192,3 +199,3 @@ return (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, value, (0, exports.generateImpossibleWhere)(fieldsMap[relationModelName]));
                     case "create":
-                        if (relationPermissions.create === false) {
+                        if (!relationPermissions.create) {
                             throw new Error("Not authorized");
@@ -200,9 +207,9 @@ }
                     case "connectOrCreate":
-                        if (relationPermissions.create === false) {
+                        if (!relationPermissions.create) {
                             throw new Error("Not authorized");
                         }
-                        else if (relationPermissions.read === false) {
+                        else if (!relationPermissions.read) {
                             return {
+                                create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, actionValue.create),
                                 where: (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, actionValue.where, (0, exports.generateImpossibleWhere)(fieldsMap[relationModelName])),
-                                create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, actionValue),
                             };
@@ -212,9 +219,14 @@ }
                             return {
+                                create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, actionValue.create),
                                 where: (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, actionValue.where, (0, exports.resolveWhere)(relationPermissions.read, context)),
-                                create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, actionValue),
                             };
                         }
-                        break;
+                        else {
+                            return {
+                                create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, actionValue.create),
+                                where: actionValue.where,
+                            };
+                        }
                     case "connect":
-                        if (relationPermissions.read === false) {
+                        if (!relationPermissions.read) {
                             return (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, actionValue, (0, exports.generateImpossibleWhere)(fieldsMap[relationModelName]));
@@ -246,2 +258,133 @@ }
                 switch (actionName) {
+                    case "create":
+                        if (!relationPermissions.create) {
+                            throw new Error("Not authorized");
+                        }
+                        else {
+                            return transformValue(actionValue, (value) => {
+                                return (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, value);
+                            });
+                        }
+                    case "createMany":
+                        if (!relationPermissions.create) {
+                            throw new Error("Not authorized");
+                        }
+                        break;
+                    case "connectOrCreate":
+                        if (!relationPermissions.create) {
+                            throw new Error("Not authorized");
+                        }
+                        else if (!relationPermissions.read) {
+                            return transformValue(actionValue, (value) => {
+                                return {
+                                    create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, value.create),
+                                    where: (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, value.where, (0, exports.generateImpossibleWhere)(fieldsMap[relationModelName])),
+                                };
+                            });
+                        }
+                        else if (relationPermissions.read !== true) {
+                            return transformValue(actionValue, (value) => {
+                                return {
+                                    create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, value.create),
+                                    where: (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, value.where, (0, exports.resolveWhere)(relationPermissions.read, context)),
+                                };
+                            });
+                        }
+                        else {
+                            return transformValue(actionValue, (value) => {
+                                return {
+                                    create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, value.create),
+                                    where: value.where,
+                                };
+                            });
+                        }
+                    case "set":
+                    case "connect":
+                    case "disconnect":
+                        if (!relationPermissions.read) {
+                            return transformValue(actionValue, (value) => {
+                                return (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, value, (0, exports.generateImpossibleWhere)(fieldsMap[relationModelName]));
+                            });
+                        }
+                        else if (relationPermissions.read !== true) {
+                            return transformValue(actionValue, (value) => {
+                                return (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, value, (0, exports.resolveWhere)(relationPermissions.read, context));
+                            });
+                        }
+                        break;
+                    case "update":
+                        if (!relationPermissions.update) {
+                            throw new Error("Not authorized");
+                        }
+                        else if (relationPermissions.update !== true) {
+                            return transformValue(actionValue, (value) => {
+                                return {
+                                    data: (0, exports.mergeUpdateData)(permissionsConfig, context, fieldsMap, relationModelName, value.data),
+                                    where: (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, value.where, (0, exports.resolveWhere)(relationPermissions.update, context)),
+                                };
+                            });
+                        }
+                        else {
+                            return transformValue(actionValue, (value) => {
+                                return {
+                                    data: (0, exports.mergeUpdateData)(permissionsConfig, context, fieldsMap, relationModelName, value.data),
+                                    where: value.where,
+                                };
+                            });
+                        }
+                    case "updateMany":
+                        if (!relationPermissions.update) {
+                            throw new Error("Not authorized");
+                        }
+                        else if (relationPermissions.update !== true) {
+                            return transformValue(actionValue, (value) => {
+                                return {
+                                    data: value.data,
+                                    where: (0, exports.mergeWhere)(value.where, (0, exports.resolveWhere)(relationPermissions.update, context)),
+                                };
+                            });
+                        }
+                        break;
+                    case "upsert":
+                        if (!relationPermissions.create || !relationPermissions.update) {
+                            throw new Error("Not authorized");
+                        }
+                        else if (relationPermissions.update !== true) {
+                            return transformValue(actionValue, (value) => {
+                                return {
+                                    create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, value.create),
+                                    update: (0, exports.mergeUpdateData)(permissionsConfig, context, fieldsMap, relationModelName, value.update),
+                                    where: (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, value.where, (0, exports.resolveWhere)(relationPermissions.update, context)),
+                                };
+                            });
+                        }
+                        else {
+                            return transformValue(actionValue, (value) => {
+                                return {
+                                    create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, value.create),
+                                    update: (0, exports.mergeUpdateData)(permissionsConfig, context, fieldsMap, relationModelName, value.update),
+                                    where: value.where,
+                                };
+                            });
+                        }
+                    case "delete":
+                        if (!relationPermissions.delete) {
+                            throw new Error("Not authorized");
+                        }
+                        else if (relationPermissions.delete !== true) {
+                            return transformValue(actionValue, (value) => {
+                                return (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, value, (0, exports.resolveWhere)(relationPermissions.delete, context));
+                            });
+                        }
+                        break;
+                    case "deleteMany":
+                        if (!relationPermissions.delete) {
+                            throw new Error("Not authorized");
+                        }
+                        else if (relationPermissions.delete !== true) {
+                            return transformValue(actionValue, (value) => {
+                                return (0, exports.mergeWhere)(value, (0, exports.resolveWhere)(relationPermissions.delete, context));
+                            });
+                        }
+                        break;
                     default:
@@ -255,2 +398,95 @@ throw new Error("Not implemented");
                 switch (actionName) {
+                    case "create":
+                        if (!relationPermissions.create) {
+                            throw new Error("Not authorized");
+                        }
+                        else {
+                            return (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, actionValue);
+                        }
+                    case "connectOrCreate":
+                        if (!relationPermissions.create) {
+                            throw new Error("Not authorized");
+                        }
+                        else if (!relationPermissions.read) {
+                            return {
+                                create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, actionValue.create),
+                                where: (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, actionValue.where, (0, exports.generateImpossibleWhere)(fieldsMap[relationModelName])),
+                            };
+                        }
+                        else if (relationPermissions.read !== true) {
+                            return {
+                                create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, actionValue.create),
+                                where: (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, actionValue.where, (0, exports.resolveWhere)(relationPermissions.read, context)),
+                            };
+                        }
+                        else {
+                            return {
+                                create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, actionValue.create),
+                                where: actionValue.where,
+                            };
+                        }
+                    case "connect":
+                        if (!relationPermissions.read) {
+                            return (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, actionValue, (0, exports.generateImpossibleWhere)(fieldsMap[relationModelName]));
+                        }
+                        else if (relationPermissions.read !== true) {
+                            return (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, actionValue, (0, exports.resolveWhere)(relationPermissions.read, context));
+                        }
+                        break;
+                    case "disconnect":
+                        if (!relationPermissions.read) {
+                            return (0, exports.mergeWhere)(actionValue, (0, exports.generateImpossibleWhere)(fieldsMap[relationModelName]));
+                        }
+                        else if (relationPermissions.read !== true && actionValue === true) {
+                            return (0, exports.resolveWhere)(relationPermissions.read, context);
+                        }
+                        else if (relationPermissions.read !== true && actionValue !== true) {
+                            return (0, exports.mergeWhere)(actionValue, (0, exports.resolveWhere)(relationPermissions.read, context));
+                        }
+                        break;
+                    case "update":
+                        if (!relationPermissions.update) {
+                            throw new Error("Not authorized");
+                        }
+                        else if (relationPermissions.update !== true) {
+                            return {
+                                data: (0, exports.mergeUpdateData)(permissionsConfig, context, fieldsMap, relationModelName, actionValue.data),
+                                where: (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, actionValue.where, (0, exports.resolveWhere)(relationPermissions.update, context)),
+                            };
+                        }
+                        else {
+                            return {
+                                data: (0, exports.mergeUpdateData)(permissionsConfig, context, fieldsMap, relationModelName, actionValue.data),
+                                where: actionValue.where,
+                            };
+                        }
+                    case "upsert":
+                        if (!relationPermissions.create || !relationPermissions.update) {
+                            throw new Error("Not authorized");
+                        }
+                        else if (relationPermissions.update !== true) {
+                            return {
+                                create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, actionValue.create),
+                                update: (0, exports.mergeUpdateData)(permissionsConfig, context, fieldsMap, relationModelName, actionValue.update),
+                                where: (0, exports.mergeWhereUnique)(fieldsMap, relationModelName, actionValue.where, (0, exports.resolveWhere)(relationPermissions.update, context)),
+                            };
+                        }
+                        else {
+                            return {
+                                create: (0, exports.mergeCreateData)(permissionsConfig, context, fieldsMap, relationModelName, actionValue.create),
+                                update: (0, exports.mergeUpdateData)(permissionsConfig, context, fieldsMap, relationModelName, actionValue.update),
+                                where: actionValue.where,
+                            };
+                        }
+                    case "delete":
+                        if (!relationPermissions.delete) {
+                            throw new Error("Not authorized");
+                        }
+                        else if (relationPermissions.delete !== true && actionValue === true) {
+                            return (0, exports.resolveWhere)(relationPermissions.delete, context);
+                        }
+                        else if (relationPermissions.delete !== true && actionValue !== true) {
+                            return (0, exports.mergeWhere)(actionValue, (0, exports.resolveWhere)(relationPermissions.delete, context));
+                        }
+                        break;
                     default:
@@ -257,0 +493,0 @@ throw new Error("Not implemented");

package.json

 {
   "name": "prisma-rls",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Prisma client extension for row-level security on any database",
@@ -5,0 +5,0 @@ "license": "MIT",

No alert changes

Improved metrics

Total package byte prevSize

46375

increased by47.69%

Lines of code

706

increased by50.21%

No dependency changes