better-supabase 0.14.0 → 0.15.1

package/dist/plugins/rules/index.js

@@ -1,235 +0,0 @@
-import { t as DbException } from "../../db-exception-Lngc1W49.js";
-import { n as dbError } from "../../errors-03ysrOt4.js";
-import { t as lookupOf } from "../../lookup-BaP5bI27.js";
-import { r as definePlugin } from "../../plugin-D9bYbYli.js";
-import { t as simplify } from "../../simplify-DDO0j0LI.js";
-import { o as tenantFrom, s as tenantPathsFor } from "../../claims-Bp9My7XP.js";
-//#region src/plugins/rules/index.ts
-/** Catches data-exposure and correctness mistakes; everything else off. */
-function safe() {
-	return {
-		noAdminInBrowser: "error",
-		noDeleteManyWithoutWhere: "error",
-		noSensitiveSelect: "error",
-		requireTenantContext: "error"
-	};
-}
-/** `safe()` plus performance warnings. */
-function recommended() {
-	return {
-		...safe(),
-		noUnboundedFindMany: "warn",
-		maxLimit: ["warn", 1e3],
-		requireOrderByForCursor: "warn",
-		maxIncludeDepth: ["warn", 3],
-		storagePathColumns: "warn"
-	};
-}
-/** Every rule as an error. */
-function strict() {
-	return {
-		...safe(),
-		noUnboundedFindMany: "error",
-		maxLimit: ["error", 1e3],
-		requireOrderByForCursor: "error",
-		maxIncludeDepth: ["error", 3],
-		storagePathColumns: "error",
-		requireMaxAffected: ["error", 1e3]
-	};
-}
-function levelOf(setting) {
-	if (setting === void 0) return "off";
-	return typeof setting === "string" ? setting : setting[0];
-}
-function optionOf(setting, fallback) {
-	return Array.isArray(setting) ? setting[1] : fallback;
-}
-const depths = /* @__PURE__ */ new WeakMap();
-function includeDepth(selection) {
-	let depth = depths.get(selection);
-	if (depth === void 0) {
-		depth = computeIncludeDepth(selection);
-		depths.set(selection, depth);
-	}
-	return depth;
-}
-function computeIncludeDepth(selection) {
-	let depth = 0;
-	for (const include of selection.includes) if (include.count !== void 0 || include.aggregate !== void 0) depth = Math.max(depth, 1);
-	else depth = Math.max(depth, 1 + includeDepth(include.selection));
-	return depth;
-}
-const sensitiveByTable = /* @__PURE__ */ new WeakMap();
-function sensitiveOf(table) {
-	let sensitive = sensitiveByTable.get(table);
-	if (!sensitive) {
-		sensitive = new Set(lookupOf(table).entries.filter(([, column]) => column.sensitive).map(([, column]) => column.db));
-		sensitiveByTable.set(table, sensitive);
-	}
-	return sensitive;
-}
-function sensitiveColumns(selection, table) {
-	const found = [];
-	const sensitive = sensitiveOf(table);
-	if (sensitive.size > 0) {
-		for (const column of selection.columns) if (sensitive.has(column.column)) found.push(`${table.key}.${column.column}`);
-		for (const measure of selection.aggregate?.measures ?? []) if (sensitive.has(measure.column)) found.push(`${table.key}.${measure.column}`);
-	}
-	for (const include of selection.includes) found.push(...sensitiveColumns(include.selection, include.target));
-	return found;
-}
-function isBrowser() {
-	return globalThis.window !== void 0 && globalThis.document !== void 0;
-}
-const TEXT_TYPES = /* @__PURE__ */ new Set([
-	"text",
-	"varchar",
-	"bpchar"
-]);
-const STORAGE_URL = /\/storage\/v1\/(?:object|render\/image)\/(?:public|sign|authenticated)\//;
-const templatesBySchema = /* @__PURE__ */ new WeakMap();
-/**
-* Bucket templates specific enough to identify a path: some literal text
-* besides `/`.
-*/
-function bucketTemplates(schema) {
-	let templates = templatesBySchema.get(schema);
-	if (!templates) {
-		templates = Object.values(schema.buckets ?? {}).flatMap((bucket) => typeof bucket.path === "string" ? [bucket.path] : bucket.path).filter((path) => path.replaceAll(/\{[^}]*\}|\//g, "").length > 0).map((path) => new RegExp(`^${path.split(/(\{[^}]*\})/).map((part, index) => index % 2 === 0 ? part.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&") : part.startsWith("{...") ? "[^/]+(?:/[^/]+)*" : "[^/]+").join("")}$`));
-		templatesBySchema.set(schema, templates);
-	}
-	return templates;
-}
-const urlColumnsByTable = /* @__PURE__ */ new WeakMap();
-/** Scalar text columns named `*_url`, the only ones the rule inspects. */
-function urlColumns(table) {
-	let columns = urlColumnsByTable.get(table);
-	if (!columns) {
-		columns = lookupOf(table).entries.map(([, column]) => column).filter((column) => column.db.endsWith("_url") && !column.array && TEXT_TYPES.has(column.type));
-		urlColumnsByTable.set(table, columns);
-	}
-	return columns;
-}
-function storedObjectColumn(op, schema) {
-	const rows = op.kind === "insert" ? op.rows : op.kind === "update" ? [op.set] : [];
-	if (rows.length === 0) return;
-	for (const column of urlColumns(op.table)) {
-		if (!rows.some((row) => column.db in row)) continue;
-		const path = `${column.db.slice(0, -4)}_path`;
-		if (column.storage !== void 0) return `"${column.db}" holds paths in bucket "${column.storage}"; name it "${path}"`;
-		if (rows.some((row) => {
-			const value = row[column.db];
-			return typeof value === "string" && (STORAGE_URL.test(value) || bucketTemplates(schema).some((template) => template.test(value)));
-		})) return `"${column.db}" is given a storage object; store its path in "${path}" and build URLs with signedUrl() or renderUrl()`;
-	}
-}
-const primaryColumnsByTable = /* @__PURE__ */ new WeakMap();
-/**
-* `true` when `where` holds `pk = value` for every primary key column: one row
-* at most.
-*/
-function pinsPrimaryKey(table, where) {
-	if (!where || table.primaryKey.length === 0) return false;
-	let columns = primaryColumnsByTable.get(table);
-	if (!columns) {
-		columns = table.primaryKey.map((name) => table.columns[name]?.db ?? name);
-		primaryColumnsByTable.set(table, columns);
-	}
-	const pinned = /* @__PURE__ */ new Set();
-	const visit = (condition) => {
-		if (condition.kind === "and") for (const item of condition.items) visit(item);
-		else if (condition.kind === "column" && condition.op === "eq" && condition.path === void 0) pinned.add(condition.column);
-	};
-	visit(where);
-	return columns.every((column) => pinned.has(column));
-}
-function checks(rules) {
-	const maxLimit = optionOf(rules.maxLimit, 1e3);
-	const maxDepth = optionOf(rules.maxIncludeDepth, 3);
-	const maxAffected = optionOf(rules.requireMaxAffected, 1e3);
-	return {
-		noUnboundedFindMany: (op) => op.kind === "select" && op.single === void 0 && !op.head && op.limit === void 0 && op.selection.aggregate === void 0 ? "findMany without limit reads every visible row" : void 0,
-		maxLimit: (op) => {
-			if (op.kind !== "select" || op.limit === void 0) return;
-			const limit = op.lookAhead === true ? op.limit - 1 : op.limit;
-			return limit > maxLimit ? `limit ${limit} is above the maximum of ${maxLimit}` : void 0;
-		},
-		requireOrderByForCursor: (op) => op.kind === "select" && !op.head && op.unpaged !== true && op.source === void 0 && op.orderBy.length === 0 && (op.offset !== void 0 || op.limit !== void 0 && op.limit > 1) ? "paging without orderBy returns rows in no stable order" : void 0,
-		maxIncludeDepth: (op) => {
-			const max = maxDepth;
-			const selection = op.kind === "select" ? op.selection : op.returning;
-			const depth = selection ? includeDepth(selection) : 0;
-			return depth > max ? `includes nest ${depth} levels deep (maximum ${max})` : void 0;
-		},
-		requireTenantContext: (op, { context, schema }) => {
-			if (!op.table.flags.tenant || context.actor?.kind === "service") return;
-			const claim = optionOf(rules.requireTenantContext, void 0);
-			const paths = tenantPathsFor(claim, schema);
-			if (tenantFrom(context, paths) !== void 0) return;
-			return `"${op.table.key}" is tenant-scoped but the request has no tenant (context.tenant or claim ${paths.map((path) => `"${path}"`).join(" or ")})`;
-		},
-		noAdminInBrowser: (_op, { context }) => context.actor?.kind === "service" && isBrowser() ? "a service-role connection is running in a browser" : void 0,
-		noSensitiveSelect: (op, { options }) => {
-			if (options["sensitive"] === true || op.kind !== "select") return;
-			const columns = sensitiveColumns(op.selection, op.table);
-			return columns.length > 0 ? `reads sensitive column(s) ${columns.join(", ")}; pass { sensitive: true } to allow` : void 0;
-		},
-		noDeleteManyWithoutWhere: (op) => op.kind === "delete" && simplify(op.where) === true ? "delete without where removes every visible row" : void 0,
-		requireMaxAffected: (op) => {
-			if (op.kind !== "update" && op.kind !== "delete") return;
-			if (op.maxAffected === void 0) return pinsPrimaryKey(op.table, op.where) ? void 0 : `${op.kind === "update" ? "updateMany" : "deleteMany"} without maxAffected can change every row its where matches`;
-			return op.maxAffected > maxAffected ? `maxAffected ${op.maxAffected} is above the maximum of ${maxAffected}` : void 0;
-		},
-		storagePathColumns: (op, { schema }) => storedObjectColumn(op, schema)
-	};
-}
-function defaultReport(violation) {
-	if (violation.level === "warn") console.warn(`[better-supabase] ${violation.rule} (${violation.table}): ${violation.message}`);
-}
-/**
-* Runtime query rules, checked before each request is built:
-*
-* ```ts
-* defineSupabase(schema).use(rules({ rules: recommended() }));
-* ```
-*
-* Runs first (`enforce: 'first'`) so it sees the query as written, before
-* tenant or soft-delete filters are added. Pair with the static
-* `better-supabase/lint` plugin to catch the same mistakes in the editor.
-*/
-function rules(options = {}) {
-	const set = options.rules ?? recommended();
-	const report = options.report ?? defaultReport;
-	const all = checks(set);
-	const active = Object.keys(all).flatMap((rule) => {
-		const level = levelOf(set[rule]);
-		return level === "off" ? [] : [{
-			rule,
-			level,
-			check: all[rule]
-		}];
-	});
-	return definePlugin({
-		name: "rules",
-		enforce: "first",
-		scopes: [],
-		transformQuery(op, hook) {
-			for (const { rule, level, check } of active) {
-				const message = check(op, hook);
-				if (message === void 0) continue;
-				const violation = {
-					rule,
-					level,
-					table: op.table.key,
-					operation: op.kind,
-					message
-				};
-				report(violation);
-				if (level === "error") throw new DbException(dbError("invalid_request", `${rule}: ${message}`, { table: op.table.key }));
-			}
-			return op;
-		}
-	});
-}
-//#endregion
-export { recommended, rules, safe, strict };

package/dist/plugins/soft-delete/index.d.ts

@@ -1,39 +0,0 @@
-import { t as AsyncResult } from "../../result-C6jDfedy.js";
-import { tt as PrimaryKeyValue } from "../../executor-CPyrQdjh.js";
-import { d as Plugin, o as HasFlag, p as RepositoryExtension } from "../../plugin-Ar5546xh.js";
-//#region src/plugins/soft-delete/index.d.ts
-export interface SoftDeleteFindArgs {
-  /** Include soft-deleted rows of the queried table. */
-  readonly withDeleted?: boolean;
-  /** Only return soft-deleted rows of the queried table. */
-  readonly onlyDeleted?: boolean;
-}
-export interface SoftDeleteDeleteArgs {
-  /** Delete the row for real instead of setting the soft-delete column. */
-  readonly hard?: boolean;
-}
-export interface SoftDeleteMethods<K> {
-  /** Clears the soft-delete column. `not_found` when the row does not exist. */
-  readonly restore: (key: K, args?: {
-    readonly signal?: AbortSignal;
-  }) => AsyncResult<void>;
-}
-export interface SoftDeleteExtension extends RepositoryExtension {
-  readonly methods: HasFlag<this["M"], this["T"], "softDelete"> extends true ? SoftDeleteMethods<PrimaryKeyValue<this["M"], this["T"]>> : unknown;
-  readonly findArgs: HasFlag<this["M"], this["T"], "softDelete"> extends true ? SoftDeleteFindArgs : unknown;
-  readonly deleteArgs: HasFlag<this["M"], this["T"], "softDelete"> extends true ? SoftDeleteDeleteArgs : unknown;
-}
-/**
- * Soft delete for tables generated with `Flags.softDelete`:
- *
- * - Reads, updates and deletes skip deleted rows, including inside includes and
- *   relation filters (`withDeleted` / `onlyDeleted` change the root table);
- * - `delete` sets the column instead (`{ hard: true }` really deletes);
- * - `restore(key)` clears it.
- *
- * Deletes become updates without `RETURNING`, so a SELECT policy that hides
- * deleted rows does not make them fail. `deleteMany({ returning: true })` keeps
- * `RETURNING`, which needs a SELECT policy that still shows the row.
- */
-export declare function softDelete(): Plugin<"softDelete", SoftDeleteExtension>;
-//#endregion

package/dist/plugins/soft-delete/index.js

@@ -1,90 +0,0 @@
-import { t as and } from "../../types-R6syp1el.js";
-import { a as ok, t as AsyncResult } from "../../result-B3m7xtRY.js";
-import { r as definePlugin } from "../../plugin-D9bYbYli.js";
-import { n as scopeOperation } from "../../scope-DgWjuXUw.js";
-import { a as insertsOnly, c as withDefault, i as guardManaged, o as isNotNull, s as isNull, t as dbName } from "../../shared-LmlfYPv4.js";
-//#region src/plugins/soft-delete/index.ts
-function deletedColumn(table) {
-	return dbName(table, table.flags.softDelete);
-}
-function scopeFor(table) {
-	const column = deletedColumn(table);
-	return column ? isNull(column) : void 0;
-}
-/**
-* Soft delete for tables generated with `Flags.softDelete`:
-*
-* - Reads, updates and deletes skip deleted rows, including inside includes and
-*   relation filters (`withDeleted` / `onlyDeleted` change the root table);
-* - `delete` sets the column instead (`{ hard: true }` really deletes);
-* - `restore(key)` clears it.
-*
-* Deletes become updates without `RETURNING`, so a SELECT policy that hides
-* deleted rows does not make them fail. `deleteMany({ returning: true })` keeps
-* `RETURNING`, which needs a SELECT policy that still shows the row.
-*/
-function softDelete() {
-	return definePlugin({
-		name: "softDelete",
-		enforce: "pre",
-		scopes: ["softDelete"],
-		describe(api) {
-			for (const { table } of api.resources) {
-				const flag = table.flags.softDelete;
-				if (!flag) continue;
-				api.markReadOnly(table.key, flag, "Set when the row is deleted. Deleted rows are not returned, and delete sets this column instead of removing the row.");
-			}
-		},
-		transformQuery(op, { options }) {
-			const hardDelete = op.kind === "delete" && options["hard"] === true;
-			const withDeleted = options["withDeleted"] === true || hardDelete;
-			const onlyDeleted = options["onlyDeleted"] === true;
-			const scoped = scopeOperation(op, scopeFor, !withDeleted && !onlyDeleted);
-			const column = deletedColumn(op.table);
-			if (!onlyDeleted || !column || scoped.kind === "insert") return scoped;
-			return {
-				...scoped,
-				where: and(scoped.where, isNotNull(column))
-			};
-		},
-		beforeMutation(op, { table, options, now }) {
-			const column = deletedColumn(table);
-			if (!column) return op;
-			guardManaged(op, [column], "softDelete", options);
-			if (op.kind === "insert") {
-				if (insertsOnly(op)) return op;
-				return {
-					...op,
-					rows: op.rows.map((row) => withDefault(row, column, null))
-				};
-			}
-			if (op.kind !== "delete" || options["hard"] === true) return op;
-			return {
-				kind: "update",
-				intent: "softDelete",
-				table,
-				set: { [column]: now().toString() },
-				where: op.where,
-				returning: options["returning"] === true ? op.returning : void 0,
-				...op.maxAffected === void 0 ? {} : { maxAffected: op.maxAffected },
-				...op.count === void 0 ? {} : { count: op.count }
-			};
-		},
-		repository({ table, base }) {
-			const flag = table.flags.softDelete;
-			if (!flag) return;
-			const update = base["update"];
-			return { restore: (key, args) => AsyncResult.from(async () => {
-				const result = await update(key, { [flag]: null }, {
-					...args,
-					withDeleted: true,
-					returning: false,
-					override: true
-				});
-				return result.ok ? ok(void 0) : result;
-			}) };
-		}
-	});
-}
-//#endregion
-export { softDelete };

package/dist/plugins/tenant/index.d.ts

@@ -1,60 +0,0 @@
-import { lt as SchemaMeta } from "../../executor-CPyrQdjh.js";
-import { d as Plugin, m as RequestContext, o as HasFlag, p as RepositoryExtension } from "../../plugin-Ar5546xh.js";
-//#region src/plugins/tenant/index.d.ts
-/**
- * Dotted paths to the string claims of `C` (up to three levels), e.g.
- * `'tenant_id' | 'app_metadata.tenant_id'`. Any string without a claims type.
- */
-export type ClaimPath<C> = unknown extends C ? string : StringPaths<C, [1, 2, 3]>;
-type StringPaths<T, Depth extends readonly unknown[]> = T extends object ? T extends readonly unknown[] ? never : { [K in keyof T & string]-?: (NonNullable<T[K]> extends string ? K : never) | (Depth extends readonly [unknown, ...infer Rest] ? `${K}.${StringPaths<NonNullable<T[K]>, Rest>}` : never); }[keyof T & string] : never;
-/**
- * `C` is the claims type (`betterSupabase.claims(schema)`'s output); it types
- * `claim`.
- */
-export interface TenantOptions<C = unknown> {
-  /**
-   * JWT claim path(s) holding the tenant id when `context.tenant` is not set.
-   * Dots walk into objects. Defaults to `config.claims.tenant` (`tenant_id`),
-   * then the same key in `app_metadata`. `user_metadata` is never a source:
-   * users can write it.
-   */
-  readonly claim?: ClaimPath<C> | readonly ClaimPath<C>[];
-  /** Custom resolution, e.g. from a header validated against memberships. */
-  readonly resolve?: (context: RequestContext) => string | undefined;
-  /**
-   * What happens on a tenant table without a tenant in the context: `error`
-   * (default) fails with `forbidden`; `skip` leaves it to RLS.
-   */
-  readonly onMissing?: "error" | "skip";
-  /**
-   * The request header `resolve` reads the tenant from. The plugin does not
-   * read it; `defineApi` documents it as a parameter of tenant tables.
-   */
-  readonly header?: string;
-}
-export interface TenantFindArgs {
-  /**
-   * Skip the tenant filter for this call (admin tooling, jobs). RLS still
-   * applies.
-   */
-  readonly allTenants?: boolean;
-}
-export interface TenantExtension extends RepositoryExtension {
-  readonly findArgs: HasFlag<this["M"], this["T"], "tenant"> extends true ? TenantFindArgs : unknown;
-  readonly methods: unknown;
-  readonly deleteArgs: HasFlag<this["M"], this["T"], "tenant"> extends true ? TenantFindArgs : unknown;
-}
-/**
- * The tenant for a request: `context.tenant`, then the configured claim.
- * `schema` supplies the default claim (`config.claims.tenant`).
- */
-export declare function resolveTenant<C = unknown>(context: RequestContext, options?: TenantOptions<C>, schema?: Pick<SchemaMeta, "claims">): string | undefined;
-/**
- * Multi-tenancy for tables generated with `Flags.tenant`. Scopes reads, updates
- * and deletes to the request's tenant (nested includes and relation filters
- * too), fills the tenant column on insert and rejects writes that would move
- * rows to another tenant. It complements RLS; it does not replace it.
- */
-export declare function tenant<C = unknown>(options?: TenantOptions<C>): Plugin<"tenant", TenantExtension>;
-//#endregion
-export {};

package/dist/plugins/tenant/index.js

@@ -1,119 +0,0 @@
-import { t as DbException } from "../../db-exception-Lngc1W49.js";
-import { n as dbError } from "../../errors-03ysrOt4.js";
-import { a as spansAllTenants, r as definePlugin } from "../../plugin-D9bYbYli.js";
-import { n as scopeOperation } from "../../scope-DgWjuXUw.js";
-import { o as tenantFrom, s as tenantPathsFor } from "../../claims-Bp9My7XP.js";
-import { a as insertsOnly, n as equals, r as forbidden, t as dbName } from "../../shared-LmlfYPv4.js";
-//#region src/plugins/tenant/index.ts
-/**
-* The tenant for a request: `context.tenant`, then the configured claim.
-* `schema` supplies the default claim (`config.claims.tenant`).
-*/
-function resolveTenant(context, options = {}, schema) {
-	if (options.resolve) return options.resolve(context);
-	const claim = options.claim;
-	return tenantFrom(context, tenantPathsFor(claim, schema));
-}
-/** Tenant columns may be numeric; the resolved tenant is always a string. */
-function sameTenant(value, id) {
-	if (value === id) return true;
-	return (typeof value === "number" || typeof value === "bigint") && String(value) === id;
-}
-function tenantColumn(table) {
-	return dbName(table, table.flags.tenant);
-}
-/**
-* Multi-tenancy for tables generated with `Flags.tenant`. Scopes reads, updates
-* and deletes to the request's tenant (nested includes and relation filters
-* too), fills the tenant column on insert and rejects writes that would move
-* rows to another tenant. It complements RLS; it does not replace it.
-*/
-function tenant(options = {}) {
-	const onMissing = options.onMissing ?? "error";
-	/** A context is fixed for a connection, so its tenant is resolved once. */
-	const resolved = /* @__PURE__ */ new WeakMap();
-	const resolvedFor = (context, schema) => {
-		let id = resolved.get(context);
-		if (id === void 0 && !resolved.has(context)) {
-			id = resolveTenant(context, options, schema);
-			resolved.set(context, id);
-		}
-		return id;
-	};
-	const missing = (table) => {
-		throw new DbException(dbError("forbidden", `No tenant in the request context for "${table.key}"`));
-	};
-	const current = (table, context, schema) => {
-		const id = resolvedFor(context, schema);
-		if (id === void 0 && onMissing === "error" && tenantColumn(table)) missing(table);
-		return id;
-	};
-	return definePlugin({
-		name: "tenant",
-		scopes: ["tenant"],
-		describe(api) {
-			for (const { table } of api.resources) {
-				const flag = table.flags.tenant;
-				if (!flag) continue;
-				api.markReadOnly(table.key, flag, "Set from the request's tenant.");
-				if (options.header) api.addParameter(table.key, {
-					name: options.header,
-					in: "header",
-					required: onMissing === "error",
-					description: "The tenant the request acts for.",
-					schema: { type: "string" }
-				});
-			}
-		},
-		context(context, { schema }) {
-			if (spansAllTenants(context)) return context;
-			const id = resolvedFor(context, schema);
-			if (id === void 0 || id === context.tenant) return context;
-			const derived = {
-				...context,
-				tenant: id
-			};
-			resolved.set(derived, id);
-			return derived;
-		},
-		transformQuery(op, { context, schema, options: call }) {
-			if (call["allTenants"] === true || spansAllTenants(context)) return op;
-			const id = resolvedFor(context, schema);
-			if (id === void 0) {
-				if (onMissing === "error") scopeOperation(op, (table) => tenantColumn(table) ? missing(table) : void 0);
-				return op;
-			}
-			return scopeOperation(op, (table) => {
-				const column = tenantColumn(table);
-				return column ? equals(column, id) : void 0;
-			});
-		},
-		beforeMutation(op, { table, context, schema, options: call }) {
-			const column = tenantColumn(table);
-			if (!column || call["allTenants"] === true || spansAllTenants(context)) return op;
-			const id = current(table, context, schema);
-			if (id === void 0) return op;
-			switch (op.kind) {
-				case "insert":
-					if (!insertsOnly(op) && !op.onConflict?.columns.includes(column)) forbidden(`An upsert on ${table.key} that updates on conflict needs the tenant column "${column}" in its conflict target`);
-					return {
-						...op,
-						rows: op.rows.map((row) => {
-							if (column in row && !sameTenant(row[column], id)) forbidden(`Cannot write a ${table.key} row for another tenant`);
-							return {
-								...row,
-								[column]: id
-							};
-						})
-					};
-				case "update":
-					if (column in op.set && !sameTenant(op.set[column], id)) forbidden(`Cannot move a ${table.key} row to another tenant`);
-					return op;
-				case "delete": return op;
-				default: return op;
-			}
-		}
-	});
-}
-//#endregion
-export { resolveTenant, tenant };

package/dist/plugins/timestamps/index.d.ts

@@ -1,11 +0,0 @@
-import { d as Plugin } from "../../plugin-Ar5546xh.js";
-//#region src/plugins/timestamps/index.d.ts
-/**
- * Stamps the columns generated as `Flags.timestamps`: `createdAt` on insert,
- * `updatedAt` on insert and update. A call that sets either column fails with
- * `invalid_request` unless it passes `{ override: true }`, which keeps the
- * caller's values. Pair it with the `updated-at` SQL module trigger to cover
- * writes that bypass the app.
- */
-export declare function timestamps(): Plugin<"timestamps">;
-//#endregion

package/dist/plugins/timestamps/index.js

@@ -1,47 +0,0 @@
-import { r as definePlugin } from "../../plugin-D9bYbYli.js";
-import { a as insertsOnly, c as withDefault, i as guardManaged, t as dbName } from "../../shared-LmlfYPv4.js";
-//#region src/plugins/timestamps/index.ts
-/**
-* Stamps the columns generated as `Flags.timestamps`: `createdAt` on insert,
-* `updatedAt` on insert and update. A call that sets either column fails with
-* `invalid_request` unless it passes `{ override: true }`, which keeps the
-* caller's values. Pair it with the `updated-at` SQL module trigger to cover
-* writes that bypass the app.
-*/
-function timestamps() {
-	return definePlugin({
-		name: "timestamps",
-		describe(api) {
-			for (const { table } of api.resources) {
-				const flags = table.flags.timestamps;
-				if (flags?.createdAt) api.markReadOnly(table.key, flags.createdAt, "Set by the server when the row is created.");
-				if (flags?.updatedAt) api.markReadOnly(table.key, flags.updatedAt, "Set by the server on every write.");
-			}
-		},
-		beforeMutation(op, { table, now, options }) {
-			const flags = table.flags.timestamps;
-			if (!flags) return op;
-			const created = dbName(table, flags.createdAt);
-			const updated = dbName(table, flags.updatedAt);
-			guardManaged(op, [created, updated], "timestamps", options);
-			const stamp = now().toString();
-			switch (op.kind) {
-				case "insert": {
-					const stampCreated = insertsOnly(op);
-					return {
-						...op,
-						rows: op.rows.map((row) => withDefault(stampCreated ? withDefault(row, created, stamp) : row, updated, stamp))
-					};
-				}
-				case "update": return {
-					...op,
-					set: withDefault(op.set, updated, stamp)
-				};
-				case "delete": return op;
-				default: return op;
-			}
-		}
-	});
-}
-//#endregion
-export { timestamps };

package/dist/plugins/validation/index.d.ts

@@ -1,24 +0,0 @@
-import { t as StandardSchemaV1 } from "../../standard-DbQsD2xZ.js";
-import { d as Plugin } from "../../plugin-Ar5546xh.js";
-//#region src/plugins/validation/index.d.ts
-export interface TableValidators {
-  /** Validates inserts and upserts, with app-cased keys. */
-  readonly insert?: StandardSchemaV1;
-  /** Validates update patches, with app-cased keys. */
-  readonly update?: StandardSchemaV1;
-}
-export interface ValidationOptions {
-  /**
-   * Validators per table key. The `validators` export of a generated `zod()` or
-   * `valibot()` module fits as is.
-   */
-  readonly schemas: Readonly<Record<string, TableValidators>>;
-}
-/**
- * Validates writes with Standard Schema validators (zod, valibot, arktype,
- * ...). Runs after other plugins (`enforce: 'post'`), so it sees the tenant,
- * timestamp and actor columns they fill. Failures become `validation` errors
- * (422) with issue paths; bulk writes prefix the row index.
- */
-export declare function validation(options: ValidationOptions): Plugin<"validation">;
-//#endregion