@prisma/cli-security-rules 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+declare function run(rawArgs: string[]): void;
+
+export { run };

package/dist/index.js

@@ -0,0 +1,1011 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/lib/XDGAppPaths.js
+var require_XDGAppPaths = __commonJS({
+  "../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/lib/XDGAppPaths.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports.Adapt = void 0;
+    function isBoolean(t) {
+      return typeOf(t) === "boolean";
+    }
+    function isObject(t) {
+      return typeOf(t) === "object";
+    }
+    function isString(t) {
+      return typeOf(t) === "string";
+    }
+    function typeOf(t) {
+      return typeof t;
+    }
+    function Adapt(adapter_) {
+      var meta = adapter_.meta, path2 = adapter_.path, xdg = adapter_.xdg;
+      var XDGAppPaths_ = /* @__PURE__ */ function() {
+        function XDGAppPaths_2(options_) {
+          if (options_ === void 0) {
+            options_ = {};
+          }
+          var _a, _b, _c;
+          function XDGAppPaths(options2) {
+            if (options2 === void 0) {
+              options2 = {};
+            }
+            return new XDGAppPaths_2(options2);
+          }
+          var options = isObject(options_) ? options_ : { name: options_ };
+          var suffix = (_a = options.suffix) !== null && _a !== void 0 ? _a : "";
+          var isolated_ = (_b = options.isolated) !== null && _b !== void 0 ? _b : true;
+          var namePriorityList = [
+            options.name,
+            meta.pkgMainFilename(),
+            meta.mainFilename()
+          ];
+          var nameFallback = "$eval";
+          var name = path2.parse(((_c = namePriorityList.find(function(e) {
+            return isString(e);
+          })) !== null && _c !== void 0 ? _c : nameFallback) + suffix).name;
+          XDGAppPaths.$name = function $name() {
+            return name;
+          };
+          XDGAppPaths.$isolated = function $isolated() {
+            return isolated_;
+          };
+          function isIsolated(dirOptions) {
+            var _a2;
+            dirOptions = dirOptions !== null && dirOptions !== void 0 ? dirOptions : { isolated: isolated_ };
+            var isolated = isBoolean(dirOptions) ? dirOptions : (_a2 = dirOptions.isolated) !== null && _a2 !== void 0 ? _a2 : isolated_;
+            return isolated;
+          }
+          function finalPathSegment(dirOptions) {
+            return isIsolated(dirOptions) ? name : "";
+          }
+          XDGAppPaths.cache = function cache(dirOptions) {
+            return path2.join(xdg.cache(), finalPathSegment(dirOptions));
+          };
+          XDGAppPaths.config = function config(dirOptions) {
+            return path2.join(xdg.config(), finalPathSegment(dirOptions));
+          };
+          XDGAppPaths.data = function data(dirOptions) {
+            return path2.join(xdg.data(), finalPathSegment(dirOptions));
+          };
+          XDGAppPaths.runtime = function runtime(dirOptions) {
+            return xdg.runtime() ? path2.join(xdg.runtime(), finalPathSegment(dirOptions)) : void 0;
+          };
+          XDGAppPaths.state = function state(dirOptions) {
+            return path2.join(xdg.state(), finalPathSegment(dirOptions));
+          };
+          XDGAppPaths.configDirs = function configDirs(dirOptions) {
+            return xdg.configDirs().map(function(s) {
+              return path2.join(s, finalPathSegment(dirOptions));
+            });
+          };
+          XDGAppPaths.dataDirs = function dataDirs(dirOptions) {
+            return xdg.dataDirs().map(function(s) {
+              return path2.join(s, finalPathSegment(dirOptions));
+            });
+          };
+          return XDGAppPaths;
+        }
+        return XDGAppPaths_2;
+      }();
+      return { XDGAppPaths: new XDGAppPaths_() };
+    }
+    exports.Adapt = Adapt;
+  }
+});
+
+// ../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/lib/XDG.js
+var require_XDG = __commonJS({
+  "../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/lib/XDG.js"(exports) {
+    "use strict";
+    var __spreadArray = exports && exports.__spreadArray || function(to, from) {
+      for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+      return to;
+    };
+    exports.__esModule = true;
+    exports.Adapt = void 0;
+    function Adapt(adapter_) {
+      var env = adapter_.env, osPaths = adapter_.osPaths, path2 = adapter_.path;
+      var isMacOS = /^darwin$/i.test(adapter_.process.platform);
+      var isWinOS = /^win/i.test(adapter_.process.platform);
+      function baseDir() {
+        return osPaths.home() || osPaths.temp();
+      }
+      function valOrPath(val, pathSegments) {
+        return val || path2.join.apply(path2, pathSegments);
+      }
+      var linux = function() {
+        var cache = function() {
+          return valOrPath(env.get("XDG_CACHE_HOME"), [baseDir(), ".cache"]);
+        };
+        var config = function() {
+          return valOrPath(env.get("XDG_CONFIG_HOME"), [baseDir(), ".config"]);
+        };
+        var data = function() {
+          return valOrPath(env.get("XDG_DATA_HOME"), [baseDir(), ".local", "share"]);
+        };
+        var runtime = function() {
+          return env.get("XDG_RUNTIME_DIR") || void 0;
+        };
+        var state = function() {
+          return valOrPath(env.get("XDG_STATE_HOME"), [baseDir(), ".local", "state"]);
+        };
+        return { cache, config, data, runtime, state };
+      };
+      var macos = function() {
+        var cache = function() {
+          return valOrPath(env.get("XDG_CACHE_HOME"), [baseDir(), "Library", "Caches"]);
+        };
+        var config = function() {
+          return valOrPath(env.get("XDG_CONFIG_HOME"), [baseDir(), "Library", "Preferences"]);
+        };
+        var data = function() {
+          return valOrPath(env.get("XDG_DATA_HOME"), [baseDir(), "Library", "Application Support"]);
+        };
+        var runtime = function() {
+          return env.get("XDG_RUNTIME_DIR") || void 0;
+        };
+        var state = function() {
+          return valOrPath(env.get("XDG_STATE_HOME"), [baseDir(), "Library", "State"]);
+        };
+        return { cache, config, data, runtime, state };
+      };
+      var windows = function() {
+        function appData() {
+          return valOrPath(env.get("APPDATA"), [baseDir(), "AppData", "Roaming"]);
+        }
+        function localAppData() {
+          return valOrPath(env.get("LOCALAPPDATA"), [baseDir(), "AppData", "Local"]);
+        }
+        var cache = function() {
+          return valOrPath(env.get("XDG_CACHE_HOME"), [localAppData(), "xdg.cache"]);
+        };
+        var config = function() {
+          return valOrPath(env.get("XDG_CONFIG_HOME"), [appData(), "xdg.config"]);
+        };
+        var data = function() {
+          return valOrPath(env.get("XDG_DATA_HOME"), [appData(), "xdg.data"]);
+        };
+        var runtime = function() {
+          return env.get("XDG_RUNTIME_DIR") || void 0;
+        };
+        var state = function() {
+          return valOrPath(env.get("XDG_STATE_HOME"), [localAppData(), "xdg.state"]);
+        };
+        return { cache, config, data, runtime, state };
+      };
+      var XDG_ = /* @__PURE__ */ function() {
+        function XDG_2() {
+          function XDG() {
+            return new XDG_2();
+          }
+          var extension = isMacOS ? macos() : isWinOS ? windows() : linux();
+          XDG.cache = extension.cache;
+          XDG.config = extension.config;
+          XDG.data = extension.data;
+          XDG.runtime = extension.runtime;
+          XDG.state = extension.state;
+          XDG.configDirs = function configDirs() {
+            var pathList = env.get("XDG_CONFIG_DIRS");
+            return __spreadArray([extension.config()], pathList ? pathList.split(path2.delimiter) : []);
+          };
+          XDG.dataDirs = function dataDirs() {
+            var pathList = env.get("XDG_DATA_DIRS");
+            return __spreadArray([extension.data()], pathList ? pathList.split(path2.delimiter) : []);
+          };
+          return XDG;
+        }
+        return XDG_2;
+      }();
+      return { XDG: new XDG_() };
+    }
+    exports.Adapt = Adapt;
+  }
+});
+
+// ../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/lib/OSPaths.js
+var require_OSPaths = __commonJS({
+  "../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/lib/OSPaths.js"(exports) {
+    "use strict";
+    var __spreadArray = exports && exports.__spreadArray || function(to, from) {
+      for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+      return to;
+    };
+    exports.__esModule = true;
+    exports.Adapt = void 0;
+    function isEmpty(s) {
+      return !s;
+    }
+    function Adapt(adapter_) {
+      var env = adapter_.env, os = adapter_.os, path2 = adapter_.path;
+      var isWinOS = /^win/i.test(adapter_.process.platform);
+      function normalizePath(path_) {
+        return path_ ? adapter_.path.normalize(adapter_.path.join(path_, ".")) : void 0;
+      }
+      function home() {
+        var posix = function() {
+          return normalizePath((typeof os.homedir === "function" ? os.homedir() : void 0) || env.get("HOME"));
+        };
+        var windows = function() {
+          var priorityList = [
+            typeof os.homedir === "function" ? os.homedir() : void 0,
+            env.get("USERPROFILE"),
+            env.get("HOME"),
+            env.get("HOMEDRIVE") || env.get("HOMEPATH") ? path2.join(env.get("HOMEDRIVE") || "", env.get("HOMEPATH") || "") : void 0
+          ];
+          return normalizePath(priorityList.find(function(v) {
+            return !isEmpty(v);
+          }));
+        };
+        return isWinOS ? windows() : posix();
+      }
+      function temp() {
+        function joinPathToBase(base, segments) {
+          return base ? path2.join.apply(path2, __spreadArray([base], segments)) : void 0;
+        }
+        function posix() {
+          var fallback = "/tmp";
+          var priorityList = [
+            typeof os.tmpdir === "function" ? os.tmpdir() : void 0,
+            env.get("TMPDIR"),
+            env.get("TEMP"),
+            env.get("TMP")
+          ];
+          return normalizePath(priorityList.find(function(v) {
+            return !isEmpty(v);
+          })) || fallback;
+        }
+        function windows() {
+          var fallback = "C:\\Temp";
+          var priorityListLazy = [
+            typeof os.tmpdir === "function" ? os.tmpdir : function() {
+              return void 0;
+            },
+            function() {
+              return env.get("TEMP");
+            },
+            function() {
+              return env.get("TMP");
+            },
+            function() {
+              return joinPathToBase(env.get("LOCALAPPDATA"), ["Temp"]);
+            },
+            function() {
+              return joinPathToBase(home(), ["AppData", "Local", "Temp"]);
+            },
+            function() {
+              return joinPathToBase(env.get("ALLUSERSPROFILE"), ["Temp"]);
+            },
+            function() {
+              return joinPathToBase(env.get("SystemRoot"), ["Temp"]);
+            },
+            function() {
+              return joinPathToBase(env.get("windir"), ["Temp"]);
+            },
+            function() {
+              return joinPathToBase(env.get("SystemDrive"), ["\\", "Temp"]);
+            }
+          ];
+          var v = priorityListLazy.find(function(v2) {
+            return v2 && !isEmpty(v2());
+          });
+          return v && normalizePath(v()) || fallback;
+        }
+        return isWinOS ? windows() : posix();
+      }
+      var OSPaths_ = /* @__PURE__ */ function() {
+        function OSPaths_2() {
+          function OSPaths() {
+            return new OSPaths_2();
+          }
+          OSPaths.home = home;
+          OSPaths.temp = temp;
+          return OSPaths;
+        }
+        return OSPaths_2;
+      }();
+      return { OSPaths: new OSPaths_() };
+    }
+    exports.Adapt = Adapt;
+  }
+});
+
+// ../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/platform-adapters/node.js
+var require_node = __commonJS({
+  "../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/platform-adapters/node.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k3, k22) {
+      if (k22 === void 0)
+        k22 = k3;
+      Object.defineProperty(o, k22, { enumerable: true, get: function() {
+        return m[k3];
+      } });
+    } : function(o, m, k3, k22) {
+      if (k22 === void 0)
+        k22 = k3;
+      o[k22] = m[k3];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k3 in mod)
+          if (k3 !== "default" && Object.prototype.hasOwnProperty.call(mod, k3))
+            __createBinding(result, mod, k3);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    exports.__esModule = true;
+    exports.adapter = void 0;
+    var os = __importStar(__require("os"));
+    var path2 = __importStar(__require("path"));
+    exports.adapter = {
+      atImportPermissions: { env: true },
+      env: {
+        get: function(s) {
+          return process.env[s];
+        }
+      },
+      os,
+      path: path2,
+      process
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/mod.cjs.js
+var require_mod_cjs = __commonJS({
+  "../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/mod.cjs.js"(exports, module) {
+    "use strict";
+    var OSPaths_js_1 = require_OSPaths();
+    var node_js_1 = require_node();
+    module.exports = OSPaths_js_1.Adapt(node_js_1.adapter).OSPaths;
+  }
+});
+
+// ../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/platform-adapters/node.js
+var require_node2 = __commonJS({
+  "../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/platform-adapters/node.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k3, k22) {
+      if (k22 === void 0)
+        k22 = k3;
+      Object.defineProperty(o, k22, { enumerable: true, get: function() {
+        return m[k3];
+      } });
+    } : function(o, m, k3, k22) {
+      if (k22 === void 0)
+        k22 = k3;
+      o[k22] = m[k3];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k3 in mod)
+          if (k3 !== "default" && Object.prototype.hasOwnProperty.call(mod, k3))
+            __createBinding(result, mod, k3);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    exports.__esModule = true;
+    exports.adapter = void 0;
+    var path2 = __importStar(__require("path"));
+    var os_paths_1 = __importDefault(require_mod_cjs());
+    exports.adapter = {
+      atImportPermissions: { env: true },
+      env: {
+        get: function(s) {
+          return process.env[s];
+        }
+      },
+      osPaths: os_paths_1["default"],
+      path: path2,
+      process
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/mod.cjs.js
+var require_mod_cjs2 = __commonJS({
+  "../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/mod.cjs.js"(exports, module) {
+    "use strict";
+    var XDG_js_1 = require_XDG();
+    var node_js_1 = require_node2();
+    module.exports = XDG_js_1.Adapt(node_js_1.adapter).XDG;
+  }
+});
+
+// ../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/platform-adapters/node.js
+var require_node3 = __commonJS({
+  "../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/platform-adapters/node.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k3, k22) {
+      if (k22 === void 0)
+        k22 = k3;
+      Object.defineProperty(o, k22, { enumerable: true, get: function() {
+        return m[k3];
+      } });
+    } : function(o, m, k3, k22) {
+      if (k22 === void 0)
+        k22 = k3;
+      o[k22] = m[k3];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k3 in mod)
+          if (k3 !== "default" && Object.prototype.hasOwnProperty.call(mod, k3))
+            __createBinding(result, mod, k3);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    exports.__esModule = true;
+    exports.adapter = void 0;
+    var path2 = __importStar(__require("path"));
+    var xdg_portable_1 = __importDefault(require_mod_cjs2());
+    exports.adapter = {
+      atImportPermissions: { env: true, read: true },
+      meta: {
+        mainFilename: function() {
+          var requireMain = typeof __require !== "undefined" && __require !== null && __require.main ? __require.main : { filename: void 0 };
+          var requireMainFilename = requireMain.filename;
+          var filename = (requireMainFilename !== process.execArgv[0] ? requireMainFilename : void 0) || (typeof process._eval === "undefined" ? process.argv[1] : void 0);
+          return filename;
+        },
+        pkgMainFilename: function() {
+          return process.pkg ? process.execPath : void 0;
+        }
+      },
+      path: path2,
+      process,
+      xdg: xdg_portable_1["default"]
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/mod.cjs.js
+var require_mod_cjs3 = __commonJS({
+  "../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/mod.cjs.js"(exports, module) {
+    "use strict";
+    var XDGAppPaths_js_1 = require_XDGAppPaths();
+    var node_js_1 = require_node3();
+    module.exports = XDGAppPaths_js_1.Adapt(node_js_1.adapter).XDGAppPaths;
+  }
+});
+
+// commands/index.ts
+import { defineCommand as defineCommand2, runMain } from "citty";
+
+// package.json
+var version = "0.1.0";
+
+// commands/deploy.ts
+import { defineCommand, showUsage } from "citty";
+
+// ../../common/cli-utils/error.ts
+import k from "kleur";
+function errorAndExit(message) {
+  console.error(message);
+  console.log("");
+  console.log(`${k.green(k.bold("Give us feedback"))} https://github.com/prisma/security-rules-feedback`);
+  console.log(`${k.magenta(k.bold("Join the discussion"))} https://discord.gg/community`);
+  process.exit(1);
+}
+
+// ../../common/cli-utils/getSchemaUrl.ts
+import { isAbsolute, join } from "path";
+import { default as prismaInternals } from "@prisma/internals";
+var { getSchemaWithPath, getConfig, loadEnvFile, resolveUrl, getEffectiveUrl } = prismaInternals;
+async function getSchemaUrl(schemaArg) {
+  let schemaPath = schemaArg;
+  if (schemaArg && isAbsolute(schemaArg) === false) {
+    schemaPath = join(process.cwd(), schemaArg);
+  }
+  await loadEnvFile({ schemaPath, printMessage: true });
+  const { schemas: datamodel } = await getSchemaWithPath(schemaPath);
+  const config = await getConfig({ datamodel, ignoreEnvVarErrors: false });
+  const datasource = config.datasources[0];
+  if (!datasource) {
+    return errorAndExit("No datasource found in schema.prisma");
+  }
+  return resolveUrl(getEffectiveUrl(datasource));
+}
+
+// ../../common/cli-utils/getTokenOrError.ts
+import { join as join2 } from "path";
+import { readFile } from "fs/promises";
+import { green } from "kleur/colors";
+
+// ../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/esm-wrapper/mod.esm.js
+var mod_esm_exports = {};
+__export(mod_esm_exports, {
+  default: () => mod_esm_default
+});
+var import_mod_cjs = __toESM(require_mod_cjs3(), 1);
+__reExport(mod_esm_exports, __toESM(require_mod_cjs3(), 1));
+var mod_esm_default = import_mod_cjs.default;
+
+// ../../node_modules/.pnpm/package-manager-detector@0.2.8/node_modules/package-manager-detector/dist/commands.mjs
+function npmRun(agent) {
+  return (args) => {
+    if (args.length > 1) {
+      return [agent, "run", args[0], "--", ...args.slice(1)];
+    } else {
+      return [agent, "run", args[0]];
+    }
+  };
+}
+function denoExecute() {
+  return (args) => {
+    return ["deno", "run", `npm:${args[0]}`, ...args.slice(1)];
+  };
+}
+var npm = {
+  "agent": ["npm", 0],
+  "run": npmRun("npm"),
+  "install": ["npm", "i", 0],
+  "frozen": ["npm", "ci"],
+  "global": ["npm", "i", "-g", 0],
+  "add": ["npm", "i", 0],
+  "upgrade": ["npm", "update", 0],
+  "upgrade-interactive": null,
+  "execute": ["npx", 0],
+  "execute-local": ["npx", 0],
+  "uninstall": ["npm", "uninstall", 0],
+  "global_uninstall": ["npm", "uninstall", "-g", 0]
+};
+var yarn = {
+  "agent": ["yarn", 0],
+  "run": ["yarn", "run", 0],
+  "install": ["yarn", "install", 0],
+  "frozen": ["yarn", "install", "--frozen-lockfile"],
+  "global": ["yarn", "global", "add", 0],
+  "add": ["yarn", "add", 0],
+  "upgrade": ["yarn", "upgrade", 0],
+  "upgrade-interactive": ["yarn", "upgrade-interactive", 0],
+  "execute": ["npx", 0],
+  "execute-local": ["yarn", "exec", 0],
+  "uninstall": ["yarn", "remove", 0],
+  "global_uninstall": ["yarn", "global", "remove", 0]
+};
+var yarnBerry = {
+  ...yarn,
+  "frozen": ["yarn", "install", "--immutable"],
+  "upgrade": ["yarn", "up", 0],
+  "upgrade-interactive": ["yarn", "up", "-i", 0],
+  "execute": ["yarn", "dlx", 0],
+  "execute-local": ["yarn", "exec", 0],
+  // Yarn 2+ removed 'global', see https://github.com/yarnpkg/berry/issues/821
+  "global": ["npm", "i", "-g", 0],
+  "global_uninstall": ["npm", "uninstall", "-g", 0]
+};
+var pnpm = {
+  "agent": ["pnpm", 0],
+  "run": ["pnpm", "run", 0],
+  "install": ["pnpm", "i", 0],
+  "frozen": ["pnpm", "i", "--frozen-lockfile"],
+  "global": ["pnpm", "add", "-g", 0],
+  "add": ["pnpm", "add", 0],
+  "upgrade": ["pnpm", "update", 0],
+  "upgrade-interactive": ["pnpm", "update", "-i", 0],
+  "execute": ["pnpm", "dlx", 0],
+  "execute-local": ["pnpm", "exec", 0],
+  "uninstall": ["pnpm", "remove", 0],
+  "global_uninstall": ["pnpm", "remove", "--global", 0]
+};
+var bun = {
+  "agent": ["bun", 0],
+  "run": ["bun", "run", 0],
+  "install": ["bun", "install", 0],
+  "frozen": ["bun", "install", "--frozen-lockfile"],
+  "global": ["bun", "add", "-g", 0],
+  "add": ["bun", "add", 0],
+  "upgrade": ["bun", "update", 0],
+  "upgrade-interactive": ["bun", "update", 0],
+  "execute": ["bun", "x", 0],
+  "execute-local": ["bun", "x", 0],
+  "uninstall": ["bun", "remove", 0],
+  "global_uninstall": ["bun", "remove", "-g", 0]
+};
+var deno = {
+  "agent": ["deno", 0],
+  "run": ["deno", "task", 0],
+  "install": ["deno", "install", 0],
+  "frozen": ["deno", "install", "--frozen"],
+  "global": ["deno", "install", "-g", 0],
+  "add": ["deno", "add", 0],
+  "upgrade": ["deno", "outdated", "--update", 0],
+  "upgrade-interactive": ["deno", "outdated", "--update", 0],
+  "execute": denoExecute(),
+  "execute-local": ["deno", "task", "--eval", 0],
+  "uninstall": ["deno", "remove", 0],
+  "global_uninstall": ["deno", "uninstall", "-g", 0]
+};
+var COMMANDS = {
+  "npm": npm,
+  "yarn": yarn,
+  "yarn@berry": yarnBerry,
+  "pnpm": pnpm,
+  // pnpm v6.x or below
+  "pnpm@6": {
+    ...pnpm,
+    run: npmRun("pnpm")
+  },
+  "bun": bun,
+  "deno": deno
+};
+function resolveCommand(agent, command, args) {
+  const value = COMMANDS[agent][command];
+  return constructCommand(value, args);
+}
+function constructCommand(value, args) {
+  if (value == null)
+    return null;
+  const list = typeof value === "function" ? value(args) : value.flatMap((v) => {
+    if (typeof v === "number")
+      return args;
+    return [v];
+  });
+  return {
+    command: list[0],
+    args: list.slice(1)
+  };
+}
+
+// ../../node_modules/.pnpm/package-manager-detector@0.2.8/node_modules/package-manager-detector/dist/constants.mjs
+var AGENTS = [
+  "npm",
+  "yarn",
+  "yarn@berry",
+  "pnpm",
+  "pnpm@6",
+  "bun",
+  "deno"
+];
+var LOCKS = {
+  "bun.lock": "bun",
+  "bun.lockb": "bun",
+  "deno.lock": "deno",
+  "pnpm-lock.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm",
+  "npm-shrinkwrap.json": "npm"
+};
+
+// ../../node_modules/.pnpm/package-manager-detector@0.2.8/node_modules/package-manager-detector/dist/detect.mjs
+import fs from "fs";
+import fsPromises from "fs/promises";
+import path from "path";
+import process2 from "process";
+async function detect(options = {}) {
+  const { cwd, onUnknown } = options;
+  for (const directory of lookup(cwd)) {
+    for (const lock of Object.keys(LOCKS)) {
+      if (await fileExists(path.join(directory, lock))) {
+        const name = LOCKS[lock];
+        const result2 = await parsePackageJson(path.join(directory, "package.json"), onUnknown);
+        if (result2)
+          return result2;
+        else
+          return { name, agent: name };
+      }
+    }
+    const result = await parsePackageJson(path.join(directory, "package.json"), onUnknown);
+    if (result)
+      return result;
+  }
+  return null;
+}
+function* lookup(cwd = process2.cwd()) {
+  let directory = path.resolve(cwd);
+  const { root } = path.parse(directory);
+  while (directory && directory !== root) {
+    yield directory;
+    directory = path.dirname(directory);
+  }
+}
+async function parsePackageJson(filepath, onUnknown) {
+  return !filepath || !await fileExists(filepath) ? null : handlePackageManager(filepath, onUnknown);
+}
+function handlePackageManager(filepath, onUnknown) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(filepath, "utf8"));
+    let agent;
+    if (typeof pkg.packageManager === "string") {
+      const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
+      let version2 = ver;
+      if (name === "yarn" && Number.parseInt(ver) > 1) {
+        agent = "yarn@berry";
+        version2 = "berry";
+        return { name, agent, version: version2 };
+      } else if (name === "pnpm" && Number.parseInt(ver) < 7) {
+        agent = "pnpm@6";
+        return { name, agent, version: version2 };
+      } else if (AGENTS.includes(name)) {
+        agent = name;
+        return { name, agent, version: version2 };
+      } else {
+        return onUnknown?.(pkg.packageManager) ?? null;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function fileExists(filePath) {
+  try {
+    const stats = await fsPromises.stat(filePath);
+    if (stats.isFile()) {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+
+// ../../common/cli-utils/getCommand.ts
+async function getCommand(command, args) {
+  const { agent } = await detect() ?? { agent: "npm" };
+  const result = resolveCommand(agent, command, args);
+  if (result === null) {
+    return `${command} ${args.join(" ")}`;
+  }
+  return `${result.command} ${result.args.join(" ")}`;
+}
+
+// ../../common/cli-utils/getTokenOrError.ts
+var credentialsFileDirectoryPath = new mod_esm_default("prisma-platform-cli").config();
+var credentialsFilePath = join2(credentialsFileDirectoryPath, "auth.json");
+async function getPlatformUnauthorizedError() {
+  const cmd = await getCommand("execute-local", ["prisma", "platform", "auth", "login", "--early-access"]);
+  return errorAndExit(
+    `No platform credentials found. Run ${green(cmd)} first. Alternatively you can provide a token via the \`--token\` or \`-t\` parameters, or set the 'PRISMA_TOKEN' environment variable with a token.`
+  );
+}
+async function getTokenOrError() {
+  try {
+    const credentialsContent = await readFile(credentialsFilePath, "utf-8");
+    const { token } = JSON.parse(credentialsContent);
+    return token;
+  } catch {
+    throw await getPlatformUnauthorizedError();
+  }
+}
+
+// commands/deploy.ts
+import { hc } from "hono/client";
+import k2 from "kleur";
+
+// bundler/bundle.ts
+import { Buffer as Buffer2 } from "buffer";
+import * as esbuild from "esbuild";
+import { readFile as readFile2 } from "fs/promises";
+import { builtinModules } from "module";
+import { dirname, join as join3, resolve } from "path";
+var external = [...builtinModules, ...builtinModules.map((m) => `node:${m}`)];
+async function bundle(args) {
+  const { file, tsconfig, absWorkingDir } = args;
+  const result = await esbuild.build({
+    entryPoints: [`${import.meta.dirname}/template.js`],
+    conditions: ["workerd", "worker", "browser", "import", "require", "default"],
+    plugins: [injectUserFilePlugin({ file }), injectPrismaEdgeClientPlugin()],
+    platform: "neutral",
+    // !important
+    logLevel: "error",
+    format: "esm",
+    absWorkingDir,
+    bundle: true,
+    write: false,
+    external,
+    tsconfig
+  });
+  const output = result.outputFiles[0]?.contents ?? [];
+  const bundle2 = Buffer2.from(output).toString("utf-8");
+  return bundle2;
+}
+function injectUserFilePlugin(args) {
+  const { file } = args;
+  return {
+    name: "rules-inject-user-file",
+    setup(build2) {
+      build2.onResolve({ filter: /rules-path-to-prisma-client/ }, () => {
+        return { path: `${build2.initialOptions.absWorkingDir}/${file}` };
+      });
+    }
+  };
+}
+function isJsFile(path2) {
+  return /\.(?:js|mjs|cjs|ts|tsx|jsx|cts|ctsx|cjsx|mts|mtsx|mjsx)$/.test(path2);
+}
+function injectPrismaEdgeClientPlugin() {
+  return {
+    name: "rules-inject-prisma-edge-client",
+    setup(build2) {
+      build2.onResolve({ filter: /.*/ }, async ({ resolveDir, path: path2 }) => {
+        const fullPath = resolve(join3(resolveDir, path2));
+        const dirPath = isJsFile(path2) ? dirname(fullPath) : fullPath;
+        const pkgPath = join3(dirPath, "package.json");
+        const pkg = await readFile2(pkgPath, "utf-8").then((c) => JSON.parse(c)).catch(() => ({}));
+        if (pkg.name?.startsWith("prisma-client-")) {
+          return { path: join3(dirPath, "edge.js") };
+        }
+        return {};
+      });
+    }
+  };
+}
+
+// utils/constants.ts
+var PROD_DEPLOYER_URL = "https://rules-deployer.datacdn.workers.dev/";
+
+// commands/deploy.ts
+var deploy = defineCommand({
+  meta: {
+    name: "deploy",
+    description: "Deploy your security rules"
+  },
+  args: {
+    name: {
+      type: "positional",
+      required: true,
+      description: "Name of your security rules"
+    },
+    file: {
+      type: "string",
+      required: true,
+      alias: "f",
+      description: "Path to your exported rules file"
+    },
+    tsconfig: {
+      type: "string",
+      description: "Path to your tsconfig file"
+    },
+    schema: {
+      type: "string",
+      description: "Path to your schema.prisma file"
+    },
+    help: {
+      type: "boolean",
+      alias: "h",
+      default: false
+    }
+  },
+  async run(context) {
+    const { schema, help, endpoint } = context.args;
+    const { name } = context.args;
+    const endpointUrl = endpoint ?? PROD_DEPLOYER_URL;
+    if (help)
+      return await showUsage(deploy);
+    const url = await getSchemaUrl(schema);
+    const token = await getTokenOrError();
+    const code = await getCode(context);
+    const client = hc(endpointUrl);
+    const response = await client.deploy.$post({
+      json: { url, code, name, token }
+    });
+    const { error, data } = await response.json();
+    if (error) {
+      return errorAndExit(error);
+    }
+    if (data) {
+      logSuccessMessage(data);
+    }
+  }
+});
+async function getCode(ctx) {
+  const { args } = ctx;
+  const { file, tsconfig } = args;
+  return await bundle({
+    file,
+    tsconfig,
+    absWorkingDir: process.cwd()
+  });
+}
+function logSuccessMessage(args) {
+  const { publicKey } = args;
+  const message = `Your new Policy rules were successfully deployed!
+
+You can enforce these rules with your public key:
+"${publicKey}"
+
+\`\`\`ts
+import { RulesProtectedClient } from "@prisma/extension-rules";
+
+const rulesClient = new RulesProtectedClient({
+  publicKey: "${publicKey}",
+});
+
+// run your queries as usual
+await rulesClient.user.findMany()
+\`\`\``;
+  console.log(message);
+  console.log("");
+  console.log(`${k2.green(k2.bold("Give us feedback"))} https://github.com/prisma/security-rules-feedback`);
+  console.log(`${k2.magenta(k2.bold("Join the discussion"))} https://pris.ly/discord`);
+}
+
+// commands/index.ts
+var main = defineCommand2({
+  meta: {
+    name: "rules",
+    description: "CLI for managing your security rules",
+    version
+  },
+  subCommands: {
+    deploy
+  }
+});
+function run(rawArgs) {
+  void runMain(main, { rawArgs });
+}
+export {
+  run
+};

package/dist/template.js

@@ -0,0 +1,58 @@
+// @ts-check
+
+import { withAccelerate } from "@prisma/extension-accelerate";
+
+/**
+ * Resolves the Prisma Client that will be bundled/injected into it. Performs
+ * the necessary setup to enable the Prisma Client to work with the executor.
+ * @type {import("../../deployer/user-worker/bundle.mjs").resolvePrismaClient}
+ */
+export async function resolvePrismaClient(ctx) {
+  const { env, request } = ctx;
+
+  try {
+    /** @type {any} **/
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore this is injected by the runtime
+    let { prisma } = await import("./rules-path-to-prisma-client.mjs");
+
+    const dbURL = new URL(env.DATABASE_URL ?? "MISSING_DATABASE_URL");
+    const itx = new URL(request.url).searchParams.get("itx");
+
+    const engine = prisma._originalClient._engine;
+    const dsName = Object.keys(engine.inlineDatasources ?? {})[0] ?? "db";
+    engine.config.overrideDatasources = { [dsName]: { url: dbURL.toString() } };
+
+    prisma = prisma.$extends(withAccelerate());
+    prisma = itx ? await getItxPrismaClient(prisma, JSON.parse(itx)) : prisma;
+
+    return [null, prisma];
+  } catch (error) {
+    if (error instanceof Error) {
+      return [error.message, null];
+    }
+
+    return [String(error), null];
+  }
+}
+
+// TODO: build this into the prisma client directly, at least as a private api or a test
+async function getItxPrismaClient(/** @type {any} */ prisma, /** @type {any} */ options) {
+  const optionsWithDefaults = {
+    maxWait: options?.maxWait ?? prisma._engineConfig.transactionOptions.maxWait,
+    timeout: options?.timeout ?? prisma._engineConfig.transactionOptions.timeout,
+    isolationLevel: options?.isolationLevel ?? prisma._engineConfig.transactionOptions.isolationLevel,
+  };
+  const headers = { traceparent: prisma._tracingHelper.getTraceParent() };
+  const info = await prisma._engine.transaction("start", headers, optionsWithDefaults);
+  const tx = prisma._createItxClient({ kind: "itx", ...info });
+
+  return Object.assign(tx, {
+    $commit() {
+      return prisma._engine.transaction("commit", headers, info);
+    },
+    $rollback() {
+      return prisma._engine.transaction("rollback", headers, info);
+    },
+  });
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@prisma/cli-security-rules",
+  "version": "0.1.0",
+  "sideEffects": false,
+  "description": "Policy CLI for Prisma",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./*": "./*"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint --fix .",
+    "test": ""
+  },
+  "keywords": [],
+  "dependencies": {
+    "@prisma/internals": "6.2.1",
+    "citty": "0.1.6",
+    "esbuild": "0.24.2",
+    "hono": "4.6.17",
+    "kleur": "4.1.5",
+    "ofetch": "1.4.1"
+  },
+  "devDependencies": {
+    "@prisma/client": "6.2.1",
+    "@types/node": "22.3.0",
+    "common-cli-utils": "workspace:^",
+    "npm-run-all": "4.1.5",
+    "rules-deployer": "workspace:^",
+    "rules-playground": "workspace:^",
+    "prisma": "6.2.1",
+    "tsup": "8.0.2",
+    "tsx": "4.17.0",
+    "typescript": "5.5.4",
+    "vitest": "1.5.3",
+    "wrangler": "3.105.1",
+    "zod": "3.24.1"
+  },
+  "peerDependencies": {
+    "@prisma/extension-accelerate": ">=1.2.2",
+    "prisma": ">=6.2.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist"
+  ]
+}