permdock 0.0.0 → 0.2.0

package/dist/row-check-Dt35czLy.d.ts

@@ -0,0 +1,40 @@
+//#region src/conditions/subject-settings.d.ts
+type WithSubjectOptions = {
+  /** Which settings the generated policies read; match `rls.dialect`. Default `supabase`. */
+  readonly dialect?: "supabase" | "guc" | "neon";
+  /**
+   * The local `role` setting before the claims: `authenticated` with a principal, `anon` without.
+   * `false` keeps the connection's role, for a login role that RLS already applies to.
+   */
+  readonly role?: "authenticated" | "anon" | false;
+  /** Prefix of the `guc` dialect's settings (`rls.gucPrefix`). Default `app`. */
+  readonly gucPrefix?: string;
+  /** Claim holding the principal's tenant (`rls.tenantClaim`). Default `tenant_id`. */
+  readonly tenantClaim?: string;
+  /**
+   * Further claims from the verified token, such as `user_role` or `memberships` for `jwt`-mode
+   * helpers. `sub`, `role` and the tenant claim always come from the subject.
+   */
+  readonly claims?: Readonly<Record<string, unknown>>;
+  /**
+   * Field names of the API-key claim written for a principal that acts through a credential
+   * (`rls.apiKeys`). Default `{ claim: 'api_key', scopes: 'scopes', tenant: 'tenant', roles: 'roles' }`.
+   */
+  readonly apiKeys?: {
+    readonly claim?: string;
+    readonly scopes?: string;
+    readonly tenant?: string;
+    readonly roles?: string;
+  };
+};
+//#endregion
+//#region src/conditions/row-check.d.ts
+/** Whether the row a unique key names exists, and if so whether the filter keeps it. */
+type RowCheck = {
+  readonly found: false;
+} | {
+  readonly found: true;
+  readonly granted: boolean;
+};
+//#endregion
+export { WithSubjectOptions as n, RowCheck as t };

package/dist/rpc-DOK54_CS.js

@@ -0,0 +1,89 @@
+import { t as compact } from "./compact-y6vfu2_f.js";
+import { o as requestFromContext } from "./http-SO7qGttf.js";
+import { n as tenantScope } from "./adapter-context-mlWsVGGg.js";
+import { t as adapterKernel } from "./bind-VnYn2HKq.js";
+import { n as guardIterable } from "./stream-DDpvynSB.js";
+//#region src/server/rpc.ts
+/** The tRPC and oRPC error code for a Problem Details status. */
+function rpcCode(status) {
+	switch (status) {
+		case 400: return "BAD_REQUEST";
+		case 401: return "UNAUTHORIZED";
+		case 404: return "NOT_FOUND";
+		case 429: return "TOO_MANY_REQUESTS";
+		case 503: return "SERVICE_UNAVAILABLE";
+		default: return "FORBIDDEN";
+	}
+}
+/**
+* The Problem Details body of a PermDock response, or `{ status }` when it has
+* none. An RPC error carries only this body; the response headers are dropped.
+*/
+async function problemBody(response) {
+	try {
+		return await response.json();
+	} catch {
+		return { status: response.status };
+	}
+}
+/**
+* The kernel of an RPC adapter. `contextOf` reads the procedure context from
+* its opts; `path` names the fallback `Request` for a context without one.
+*/
+function bindRpcKernel(policy, options, adapter, contextOf, path) {
+	const optsByRequest = /* @__PURE__ */ new WeakMap();
+	const requestByCtx = /* @__PURE__ */ new WeakMap();
+	const kernel = adapterKernel(policy, options, adapter, (request) => optsByRequest.get(request));
+	const requestOf = (ctx) => {
+		if (options.request !== void 0) try {
+			return options.request(ctx) ?? void 0;
+		} catch {
+			return;
+		}
+		return requestFromContext(ctx);
+	};
+	const bind = (opts) => {
+		const ctx = contextOf(opts);
+		const key = ctx;
+		const hit = requestByCtx.get(key);
+		if (hit !== void 0) return hit;
+		const request = requestOf(ctx) ?? new Request(`http://localhost/${adapter}/${path(opts)}`, { method: "POST" });
+		requestByCtx.set(key, request);
+		if (!optsByRequest.has(request)) optsByRequest.set(request, opts);
+		return request;
+	};
+	const scopeOf = (opts) => tenantScope(options.tenant, opts);
+	const connection = async (opts, connectionOptions) => kernel.connection(bind(opts), connectionOptions, await scopeOf(opts));
+	const evaluations = kernel.permdockHandler((request) => {
+		const opts = optsByRequest.get(request);
+		return opts === void 0 ? { tenant: void 0 } : scopeOf(opts);
+	});
+	const evaluate = (request, opts) => {
+		bind(opts);
+		return request.method === "GET" ? evaluations.GET(request) : evaluations.POST(request);
+	};
+	return {
+		kernel,
+		bind,
+		attach: (ctx, request) => {
+			requestByCtx.set(ctx, request);
+		},
+		scopeOf,
+		connection,
+		evaluate
+	};
+}
+/** Wraps a streamed result so revocation ends it and items the subscriber cannot read drop. */
+async function guardStream(source, open, permission, loadData, protectOptions, guard) {
+	const conn = await open(permission === null ? {} : compact({
+		permission,
+		data: loadData
+	}));
+	return guardIterable(source, conn, compact({
+		items: protectOptions?.items,
+		unwrap: guard.unwrap,
+		onRevoked: guard.onRevoked
+	}));
+}
+//#endregion
+export { rpcCode as i, guardStream as n, problemBody as r, bindRpcKernel as t };

package/dist/run-YXCJDNYk.js

@@ -0,0 +1,174 @@
+import { a as exitCodeOf, i as describeError, n as cliErrorKind, r as cliProblem } from "./errors-CWfoNg9N.js";
+import { o as cliVersion } from "./version-BvacVTZR.js";
+import { a as resolveCwd, i as readConfig } from "./config-BJiM-xAm.js";
+import { i as globalArgs, n as commands, o as resolveArgs, r as isCommand, s as stringArg, t as COMMAND_DESCRIPTIONS } from "./commands-DWOrSQic.js";
+import { stripVTControlCharacters } from "node:util";
+import { defineCommand, parseArgs, renderUsage, runCommand } from "citty";
+//#region src/cli/run.ts
+const NAMES = Object.keys(commands).filter(isCommand);
+const NO_CONFIG = {
+	config: {},
+	warnings: [],
+	file: void 0
+};
+async function run(argv, options) {
+	const stdoutChunks = [];
+	const stderrChunks = [];
+	const io = options?.io ?? {
+		stdout: (text) => {
+			stdoutChunks.push(text);
+		},
+		stderr: (text) => {
+			stderrChunks.push(text);
+		}
+	};
+	const writeOut = (text) => {
+		const line = lined(text);
+		io.stdout(line);
+		if (options?.io !== void 0) stdoutChunks.push(line);
+	};
+	const writeErr = (text) => {
+		const line = lined(text);
+		io.stderr(line);
+		if (options?.io !== void 0) stderrChunks.push(line);
+	};
+	const done = (code) => ({
+		code,
+		stdout: stdoutChunks.join(""),
+		stderr: stderrChunks.join("")
+	});
+	const flags = beforeSeparator(argv);
+	const globals = parseArgs([...flags], globalArgs);
+	const json = globals.json === true;
+	const color = io.color === true && globals.color !== false;
+	const plain = (text) => color ? text : stripVTControlCharacters(text);
+	const askedHelp = flags.includes("--help") || flags.includes("-h");
+	const first = globals._[0];
+	const name = first === "help" ? globals._[1] : first;
+	let result;
+	const configFile = stringArg(globals.config);
+	const contextFor = (cwd, loaded = NO_CONFIG) => ({
+		cwd,
+		config: loaded.config,
+		...configFile === void 0 ? {} : { configFile },
+		...loaded.file === void 0 ? {} : { configPath: loaded.file },
+		configWarnings: loaded.warnings,
+		io,
+		now: io.now?.() ?? /* @__PURE__ */ new Date(),
+		json,
+		color,
+		interactive: io.interactive === true && !json && globals.yes !== true,
+		report: (outcome) => {
+			result = outcome;
+		}
+	});
+	/** A failed run: text on stderr, or Problem Details on stdout under `--json`. */
+	const fail = (kind, message, command) => {
+		if (json) writeOut(JSON.stringify(cliProblem(kind, message, command), null, 2));
+		else writeErr(message);
+		return done(exitCodeOf(kind));
+	};
+	if (name !== void 0 && !isCommand(name)) return fail("usage", `unknown command '${name}'. Use ${new Intl.ListFormat("en-GB", { type: "disjunction" }).format(NAMES)}.`);
+	if (name === void 0 && (flags.includes("--version") || flags.includes("-v"))) {
+		writeOut(cliVersion());
+		return done(0);
+	}
+	if (askedHelp || first === "help" || name === void 0) {
+		const root = rootCommand();
+		const usage = name === void 0 ? await renderUsage(root) : await renderUsage(await load(name, contextFor(options?.cwd ?? process.cwd())), root);
+		if (name === void 0 && !askedHelp && first !== "help") {
+			writeErr(plain(usage));
+			return done(2);
+		}
+		writeOut(plain(usage));
+		return done(0);
+	}
+	const cwd = resolveCwd(stringArg(globals.cwd), options?.cwd ?? process.cwd());
+	let loaded;
+	try {
+		loaded = await readConfig(cwd, configFile);
+	} catch (error) {
+		return fail(cliErrorKind(error), describeError(error));
+	}
+	if (name !== "config") for (const warning of loaded.warnings) writeErr(`permdock: warning: ${warning}`);
+	try {
+		const command = await load(name, contextFor(cwd, loaded));
+		const rawArgs = withoutCommand(argv, name);
+		await runCommand(command, { rawArgs: normaliseValues(rawArgs, await resolveArgs(command)) });
+	} catch (error) {
+		if (!(error instanceof Error)) return fail("usage", String(error), name);
+		if (error.name === "CLIError") return fail("usage", `${name}: ${stripVTControlCharacters(error.message)}`, name);
+		return fail(cliErrorKind(error), error.message, name);
+	}
+	if (result === void 0) return done(0);
+	if (json && result.code !== 0 && !isJson(result.output)) return fail(result.code === 2 ? "usage" : "failed", result.output, name);
+	writeOut(result.output);
+	return done(result.code);
+}
+/** The root help lists commands from a static table, so it loads none of them. */
+function rootCommand() {
+	return defineCommand({
+		meta: {
+			name: "permdock",
+			description: "Collect, export, diff and check the permissions a PermDock policy declares"
+		},
+		args: {
+			...globalArgs,
+			version: {
+				type: "boolean",
+				alias: "v",
+				description: "Print the permdock version"
+			}
+		},
+		subCommands: Object.fromEntries(NAMES.map((name) => [name, defineCommand({ meta: {
+			name,
+			description: COMMAND_DESCRIPTIONS[name]
+		} })]))
+	});
+}
+async function load(name, ctx) {
+	return (await commands[name]())(ctx);
+}
+function isJson(text) {
+	try {
+		JSON.parse(text);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function lined(text) {
+	return text.endsWith("\n") ? text : `${text}\n`;
+}
+function beforeSeparator(argv) {
+	const end = argv.indexOf("--");
+	return end === -1 ? argv : argv.slice(0, end);
+}
+/** argv with the command name removed, wherever the global flags put it. */
+function withoutCommand(argv, name) {
+	const index = argv.findIndex((token, i) => token === name && argv[i - 1] !== "--cwd" && argv[i - 1] !== "--config");
+	return argv.filter((_, i) => i !== index);
+}
+/**
+* A value never starts with `-` (bar `-` itself): `--out --check` is a bare
+* `--out` and `--check`, as it was before citty, which would take `--check`
+* as the value. A bare string flag reads as `''`; a bare enum flag keeps its
+* default.
+*/
+function normaliseValues(rawArgs, def) {
+	const out = [];
+	for (const [i, token] of rawArgs.entries()) {
+		if (token === "--") {
+			out.push(...rawArgs.slice(i));
+			break;
+		}
+		const arg = token.startsWith("--") ? def[token.slice(2)] : void 0;
+		const next = rawArgs[i + 1];
+		const bare = next === void 0 || next !== "-" && next.startsWith("-");
+		if (arg?.type === "enum" && bare) continue;
+		out.push(arg?.type === "string" && bare ? `${token}=` : token);
+	}
+	return out;
+}
+//#endregion
+export { run as t };

package/dist/runtime-CB8gQFvS.js

@@ -0,0 +1,11 @@
+import { a as protectedView, s as scopedTenant } from "./views-Soe7bGSC.js";
+//#region src/svelte/protected.ts
+/** The instance for `tenant`, built once per store change rather than once per check. */
+function scopedFor(store, tenant, _generation) {
+	return scopedTenant(store.get(), tenant);
+}
+function viewFor(store, reference, data, scoped, _generation) {
+	return protectedView(store.permissionState(reference, data), store.get(), reference, data, scoped);
+}
+//#endregion
+export { viewFor as n, scopedFor as t };