@rebasepro/server-postgres 0.17.3 → 0.18.1

package/dist/src-DiB5RP2Z.js

@@ -1,541 +0,0 @@
-import { createRequire as __createRequire } from "module";
-import "process";
-__createRequire(import.meta.url);
-//#region ../types/src/types/filter-operators.ts
-/** The wire spelling of a {@link RelationAggregateSort}: `min(applications.created_at)`. */
-var RELATION_AGGREGATE_SORT_PATTERN = /^(min|max|count|sum|avg)\(([^().]+)(?:\.([^()]+))?\)$/;
-/**
-* A {@link RelationAggregateSort} as a single string — `min(applications.created_at)`,
-* `count(applications)`.
-*
-* The wire form is a string because every layer below the call site already is
-* one: `OrderByTuple` is `[string, direction]`, the REST parameter is
-* `?orderBy=key:direction`, the driver contract takes `orderBy?: string |
-* OrderByTuple[]`, and a cursor names its keys by string. `_score` established
-* the same pattern — a sort key that is not a column, spelled as one — and this
-* reuses it rather than widening five signatures to carry an object that would
-* be flattened at the end anyway.
-*
-* SQL's own spelling, so the key reads as what it compiles to. Neither `:` nor
-* `,` appears in it, which is what keeps it safe in the colon-delimited wire
-* shorthand.
-*
-* @group Models
-*/
-function encodeRelationAggregateSort(sort) {
-	return `${sort.agg}(${sort.relation}${sort.field ? `.${sort.field}` : ""})`;
-}
-/**
-* Read the string spelling back, or `undefined` if it is not one.
-*
-* `undefined` rather than a throw: this is asked of *every* sort key to find
-* out which kind it is, and an ordinary column name is not an error.
-*
-* @group Models
-*/
-function parseRelationAggregateSort(key) {
-	const match = RELATION_AGGREGATE_SORT_PATTERN.exec(key);
-	if (!match) return void 0;
-	const [, agg, relation, field] = match;
-	if (!field && agg !== "count") return void 0;
-	return {
-		agg,
-		relation,
-		...field && { field }
-	};
-}
-/** Is this sort key the object form rather than a field name? */
-function isRelationAggregateSort(key) {
-	return typeof key === "object" && key !== null && typeof key.relation === "string" && typeof key.agg === "string";
-}
-/** A sort key in the single-string form every layer below the call site speaks. */
-function sortKeyToString(key) {
-	return isRelationAggregateSort(key) ? encodeRelationAggregateSort(key) : key;
-}
-/** Maps canonical operators to their REST short-code equivalents. */
-var CANONICAL_TO_REST = {
-	"==": "eq",
-	"!=": "neq",
-	">": "gt",
-	">=": "gte",
-	"<": "lt",
-	"<=": "lte",
-	"in": "in",
-	"not-in": "nin",
-	"array-contains": "cs",
-	"array-contains-any": "csa",
-	"like": "like",
-	"ilike": "ilike",
-	"not-like": "nlike",
-	"not-ilike": "nilike",
-	"is-null": "isnull",
-	"is-not-null": "notnull"
-};
-/** Maps REST short-code operators to their canonical equivalents. */
-var REST_TO_CANONICAL = {
-	"eq": "==",
-	"neq": "!=",
-	"gt": ">",
-	"gte": ">=",
-	"lt": "<",
-	"lte": "<=",
-	"in": "in",
-	"nin": "not-in",
-	"cs": "array-contains",
-	"csa": "array-contains-any",
-	"like": "like",
-	"ilike": "ilike",
-	"nlike": "not-like",
-	"nilike": "not-ilike",
-	"isnull": "is-null",
-	"notnull": "is-not-null"
-};
-/**
-* Operators that test for null/not-null and therefore ignore their value.
-* Codecs normalize the value of these conditions to `null`.
-*/
-var NULL_OPS = /* @__PURE__ */ new Set(["is-null", "is-not-null"]);
-/**
-* Every canonical operator, in a stable order. Useful for engine capability
-* declarations ({@link DataSourceCapabilities.filterOperators}) and for
-* building operator subsets.
-* @group Models
-*/
-var ALL_WHERE_FILTER_OPS = [
-	"<",
-	"<=",
-	"==",
-	"!=",
-	">=",
-	">",
-	"in",
-	"not-in",
-	"array-contains",
-	"array-contains-any",
-	"like",
-	"ilike",
-	"not-like",
-	"not-ilike",
-	"is-null",
-	"is-not-null"
-];
-/** All canonical operator strings for runtime validation. */
-var CANONICAL_OPS = new Set(ALL_WHERE_FILTER_OPS);
-/**
-* The REST table as a `Map`, because the key `toCanonicalOp` is handed comes
-* off the wire.
-*
-* Indexed as a plain object, every `Object.prototype` member answered:
-* `toCanonicalOp("valueOf")` returned the inherited *function* as though it
-* were a `WhereFilterOp`, and every caller here treats a defined result as
-* "known operator". Same defect the REST codec's own lookup tables were
-* converted away from in `filter-dialect.ts`; this is the copy that survived
-* one package over, and it now sits under the operator validation the REST
-* parser does, which would otherwise have admitted `["constructor", x]`.
-*/
-var REST_OP_LOOKUP = new Map(Object.entries(REST_TO_CANONICAL));
-/**
-* Resolve any operator string (canonical or REST short-code) to its
-* canonical `WhereFilterOp` form. Returns `undefined` for unknown operators.
-*
-* @example
-* toCanonicalOp("==")   // "=="
-* toCanonicalOp("eq")   // "=="
-* toCanonicalOp("cs")   // "array-contains"
-* toCanonicalOp("xyz")  // undefined
-*/
-function toCanonicalOp(op) {
-	if (CANONICAL_OPS.has(op)) return op;
-	return REST_OP_LOOKUP.get(op);
-}
-//#endregion
-//#region ../types/src/types/data_source.ts
-/**
-* The default data-source key, used when a collection does not name a
-* `dataSource`. Shared by the frontend router and the backend driver
-* registry so both agree on "the default database".
-* @group Models
-*/
-var DEFAULT_DATA_SOURCE_KEY = "(default)";
-/**
-* Relation kinds assumed filterable when a driver does not say.
-*
-* `belongsTo` alone: its filter is a comparison on a column of the row being
-* filtered, the one shape that needs no query construction a driver might not
-* have. Everything else is a correlated subquery over another table.
-*
-* @group Models
-*/
-var DEFAULT_FILTERABLE_RELATION_KINDS = ["belongsTo"];
-/** @group Models */
-var POSTGRES_CAPABILITIES = {
-	key: "postgres",
-	label: "PostgreSQL",
-	supportsRelations: true,
-	supportsSubcollections: false,
-	supportsRLS: true,
-	supportsReferences: false,
-	supportsColumnTypes: true,
-	supportsRealtime: true,
-	supportsVectors: true,
-	filterOperators: ALL_WHERE_FILTER_OPS,
-	filterableRelationKinds: [
-		"belongsTo",
-		"manyToMany",
-		"hasMany",
-		"hasOne"
-	],
-	supportsRelationFieldFilters: true,
-	relationAggregateSorts: true,
-	supportsSQLAdmin: true,
-	supportsDocumentAdmin: false,
-	supportsSchemaAdmin: true
-};
-/** @group Models */
-var FIREBASE_CAPABILITIES = {
-	key: "firestore",
-	label: "Firebase / Firestore",
-	supportsRelations: false,
-	supportsSubcollections: true,
-	supportsRLS: false,
-	supportsReferences: true,
-	supportsColumnTypes: false,
-	supportsRealtime: true,
-	supportsVectors: false,
-	filterOperators: ALL_WHERE_FILTER_OPS.filter((op) => op !== "like" && op !== "ilike" && op !== "not-like" && op !== "not-ilike"),
-	filterableRelationKinds: [],
-	supportsRelationFieldFilters: false,
-	relationAggregateSorts: false,
-	supportsSQLAdmin: false,
-	supportsDocumentAdmin: false,
-	supportsSchemaAdmin: false
-};
-/** @group Models */
-var MONGODB_CAPABILITIES = {
-	key: "mongodb",
-	label: "MongoDB",
-	supportsRelations: false,
-	supportsSubcollections: true,
-	supportsRLS: false,
-	supportsReferences: true,
-	supportsColumnTypes: false,
-	supportsRealtime: false,
-	supportsVectors: false,
-	filterOperators: ALL_WHERE_FILTER_OPS,
-	filterableRelationKinds: [],
-	supportsRelationFieldFilters: false,
-	relationAggregateSorts: false,
-	supportsSQLAdmin: false,
-	supportsDocumentAdmin: true,
-	supportsSchemaAdmin: true
-};
-/**
-* Fallback capabilities when the driver is unknown.
-* Enables everything so nothing is hidden unexpectedly.
-* @group Models
-*/
-var DEFAULT_CAPABILITIES = {
-	key: "(default)",
-	label: "Default",
-	supportsRelations: true,
-	supportsSubcollections: true,
-	supportsRLS: true,
-	supportsReferences: true,
-	supportsColumnTypes: true,
-	supportsRealtime: true,
-	supportsVectors: true,
-	filterOperators: ALL_WHERE_FILTER_OPS,
-	filterableRelationKinds: DEFAULT_FILTERABLE_RELATION_KINDS,
-	supportsRelationFieldFilters: false,
-	relationAggregateSorts: false,
-	supportsSQLAdmin: true,
-	supportsDocumentAdmin: true,
-	supportsSchemaAdmin: true
-};
-var CAPABILITIES_REGISTRY = {
-	postgres: POSTGRES_CAPABILITIES,
-	firestore: FIREBASE_CAPABILITIES,
-	mongodb: MONGODB_CAPABILITIES,
-	"(default)": DEFAULT_CAPABILITIES
-};
-/**
-* Look up capabilities for a given engine key.
-* If `engine` is undefined or not found, returns `DEFAULT_CAPABILITIES`.
-* @group Models
-*/
-function getDataSourceCapabilities(engine) {
-	if (!engine) return POSTGRES_CAPABILITIES;
-	return CAPABILITIES_REGISTRY[engine] ?? DEFAULT_CAPABILITIES;
-}
-//#endregion
-//#region ../types/src/types/collections.ts
-/**
-* Type guard for PostgreSQL collections.
-* Returns true if the collection uses the Postgres engine (or the default engine).
-*
-* Generic over the *input* type, and narrows by intersection rather than
-* replacement. Narrowing to a bare `PostgresCollectionConfig` discarded whatever
-* the caller actually had — most visibly the admin panel's view model, whose
-* flattened presentation fields vanished the moment a collection passed through
-* one of these guards.
-*
-* @group Models
-*/
-function isPostgresCollectionConfig(collection) {
-	return !collection.engine || collection.engine === "postgres";
-}
-/**
-* Narrows to the SQL collection fields — `table`, `relations`,
-* `disableDefaultPolicies` — by asking the engine's declared capabilities
-* rather than by naming Postgres.
-*
-* The two halves of this already existed and were never joined. The engine
-* split (`PostgresCollectionConfig` / `FirebaseCollectionConfig` /
-* `MongoDBCollectionConfig`) said which fields belong to which engine at the
-* type level; {@link DataSourceCapabilities} said the same thing at runtime,
-* down to a `supportsRelations` flag. So call sites guarded on the capability
-* and then read a field the base type had to declare for them — which is why
-* those fields were on the base, and why a MongoDB collection could be written
-* with a `table`.
-*
-* Prefer this over {@link isPostgresCollectionConfig} wherever the question is
-* "does this collection live in a SQL table", so a custom SQL engine
-* registered through `registerDataSourceCapabilities` is included.
-*
-* @group Models
-*/
-function isRelationalCollectionConfig(collection) {
-	return getDataSourceCapabilities(collection.engine).supportsRelations;
-}
-/**
-* Reads a collection's driver-declared subcollections thunk (the `subcollections`
-* field) independent of engine identity, so engine-agnostic code doesn't have to
-* type-guard against a specific driver. Returns `undefined` when the collection
-* declares none.
-*
-* Pair with `getDataSourceCapabilities(engine).supportsSubcollections` to decide
-* whether the engine honours subcollections at all before reading them.
-* @group Models
-*/
-function getDeclaredSubcollections(collection) {
-	return collection.subcollections;
-}
-//#endregion
-//#region ../types/src/types/rls-functions.ts
-/**
-* The SQL helper functions RLS policies call, and the schema they live in.
-*
-* ## One schema, and it is ours
-*
-* Rebase creates exactly one schema in a project's database: `rebase`. These
-* three functions live in it alongside the framework's own tables, and that is
-* the whole contract — a reader can look at a database and know precisely which
-* namespace belongs to the framework and that nothing else was touched.
-*
-* It used to be two. `uid()`, `jwt()` and `roles()` sat in a schema called
-* `auth`, which is Supabase's name, chosen so that a developer who had written
-* Supabase RLS would recognise `auth.uid()`. The familiarity was real but the
-* name was not Rebase's to take, and taking it had a concrete cost: pointing
-* Rebase at a database that already had a Supabase `auth` schema meant
-* `CREATE OR REPLACE FUNCTION auth.uid() RETURNS text` against Supabase's
-* `RETURNS uuid`, which Postgres rejects outright —
-*
-*     ERROR:  cannot change return type of existing function
-*     HINT:   Use DROP FUNCTION auth.uid() first.
-*
-* — and the failure landed inside a catch-all that logged a warning and carried
-* on, leaving a database with auth tables, no helper functions, and policies
-* calling functions that did not exist. Under `rebase db migrate` the same
-* statements aborted the migration instead.
-*
-* `rebase.uid()` collides with nobody. A Supabase database keeps its `auth`
-* schema untouched and gains a `rebase` one, which is what a gradual migration
-* needs.
-*
-* ## Why functions at all, rather than inlining `current_setting`
-*
-* Because the indirection has already been spent once. `uid()` resolves
-* `app.uid` and falls back to the pre-rename `app.user_id`, so that during a
-* rolling deploy — old and new pods serving one database — both eras resolve
-* the principal. That was a single `CREATE OR REPLACE`. Inlined into policy
-* bodies it would have been a rewrite of every policy on every table.
-*
-* ## Why the name is not configurable
-*
-* A policy body is stored SQL: Postgres parses `USING (…)` once and keeps it, so
-* these strings are written into every policy in every database Rebase has
-* provisioned. Everything that reads policies back — the SQL-to-policy parser
-* behind the admin UI, the drift checker, `rls-check` — would have to know the
-* configured value to recognise its own output. One frozen name is the feature.
-*/
-/** The schema Rebase owns. The only schema Rebase creates. */
-var REBASE_SCHEMA = "rebase";
-/**
-* The principal of the current request, as text, or NULL in the server context.
-*
-* Never NULL for a user request — an anonymous one carries
-* {@link ANONYMOUS_USER_ID} — which is what makes `IS NULL` a reliable test for
-* the trusted server plane and `IS NOT NULL` a tautology.
-*/
-var RLS_UID_SQL = `${REBASE_SCHEMA}.uid()`;
-/** The request's roles as a comma-separated string, for `string_to_array`. */
-var RLS_ROLES_SQL = `${REBASE_SCHEMA}.roles()`;
-`${REBASE_SCHEMA}`;
-/**
-* The pre-1.0 spellings, for recognising policies and hand-written SQL that
-* predate the move.
-*
-* Kept because policies outlive the server that wrote them: a database migrated
-* by an older release still holds `auth.uid()` in its policy bodies until the
-* next push or boot recompiles them, and anything that reads policies back has
-* to recognise both eras or report the framework's own output as foreign drift.
-* Also used to give a project whose `securityRules` contain raw `auth.uid()` a
-* message naming the replacement, instead of a parse failure.
-*/
-var LEGACY_RLS_SCHEMA = "auth";
-`${LEGACY_RLS_SCHEMA}`;
-`${LEGACY_RLS_SCHEMA}`;
-`${LEGACY_RLS_SCHEMA}`;
-/**
-* Rewrites the pre-1.0 function calls in a fragment of policy SQL.
-*
-* Deliberately anchored on a word boundary and the schema qualifier, so a column
-* called `auth_uid` or a table named `auth` is left alone.
-*/
-function rewriteLegacyRlsFunctions(sql) {
-	return sql.replace(/\bauth\.(uid|jwt|roles)\s*\(\s*\)/gi, (_match, fn) => `${REBASE_SCHEMA}.${fn.toLowerCase()}()`);
-}
-/** Whether a fragment of SQL still calls the pre-1.0 functions. */
-function usesLegacyRlsFunctions(sql) {
-	return /\bauth\.(uid|jwt|roles)\s*\(\s*\)/i.test(sql);
-}
-//#endregion
-//#region ../types/src/types/resources.ts
-var GLOBAL_KEY = Symbol.for("@rebasepro/types.resourceRegistry");
-function registry() {
-	const g = globalThis;
-	let existing = g[GLOBAL_KEY];
-	if (!existing) {
-		existing = {
-			kinds: /* @__PURE__ */ new Map(),
-			declarations: /* @__PURE__ */ new Map()
-		};
-		g[GLOBAL_KEY] = existing;
-	}
-	return existing;
-}
-/** Register a resource kind. Idempotent for an identical spec; throws on a conflicting one. */
-function registerResourceKind(spec) {
-	const existing = registry().kinds.get(spec.kind);
-	if (existing && JSON.stringify(existing) !== JSON.stringify(spec)) throw new Error(`Resource kind "${spec.kind}" is already registered with a different definition. Two packages cannot define the same kind.`);
-	registry().kinds.set(spec.kind, spec);
-}
-/** Every declared resource, in declaration order, optionally filtered by kind. */
-function declaredResources(kind) {
-	const all = [...registry().declarations.values()];
-	return kind ? all.filter((r) => r.kind === kind) : all;
-}
-//#endregion
-//#region ../types/src/types/resource_kinds.ts
-/**
-* The kinds Rebase ships, and the constructors a project declares them with.
-*
-* Each kind is registered rather than hardcoded, so a fourth one arrives
-* without editing a manifest schema, a validator and a switch statement. That
-* cost is precisely why databases and buckets ended up declared in different
-* files with different rules — the cheapest thing to do was always to bolt the
-* new kind onto whichever home was nearest.
-*
-* A kind owns its engine list. `custom:<id>` is always accepted, so a build
-* that ships an engine this package has never heard of says so at the call site
-* instead of looking like a typo of one that exists.
-*/
-registerResourceKind({
-	kind: "database",
-	engines: [
-		"postgres",
-		"mongodb",
-		"firestore",
-		"sqlite"
-	],
-	defaultEngine: "postgres",
-	envBases: [
-		"DATABASE_URL",
-		"REBASE_DRIVER",
-		"REBASE_DB_POOL_MAX"
-	],
-	optionKeys: [
-		"databaseId",
-		"migrations",
-		"extensions"
-	],
-	implicitDefault: true
-});
-/**
-* The extensions the project's databases gave Rebase leave to install.
-*
-* A flat union rather than a per-database answer, because the surfaces that ask
-* — `rebase db push` and the boot schema-ensure — drive one connection and
-* generate one `schema.sql` for every collection regardless of `dataSource`.
-* Splitting the permission by data source would be a distinction the rest of
-* that pipeline does not make, and a false precision is worse than none.
-*
-* Empty for a project that declared nothing, which is every project that has
-* not opted in — so this reads as a refusal by default, on purpose.
-*/
-function declaredDatabaseExtensions() {
-	const names = /* @__PURE__ */ new Set();
-	for (const declaration of declaredResources("database")) {
-		const declared = declaration.options.extensions;
-		if (!Array.isArray(declared)) continue;
-		for (const name of declared) if (typeof name === "string" && name.trim()) names.add(name.trim());
-	}
-	return [...names].sort();
-}
-registerResourceKind({
-	kind: "bucket",
-	engines: [
-		"local",
-		"s3",
-		"gcs",
-		"azure",
-		"firebase"
-	],
-	defaultEngine: "local",
-	envBases: [
-		"S3_BUCKET",
-		"GCS_BUCKET",
-		"STORAGE_BUCKET",
-		"STORAGE_PUBLIC_URL"
-	],
-	envBasesByEngine: {
-		local: ["STORAGE_BUCKET"],
-		s3: [
-			"S3_BUCKET",
-			"STORAGE_ENDPOINT",
-			"STORAGE_REGION",
-			"STORAGE_PUBLIC_URL"
-		],
-		gcs: ["GCS_BUCKET", "STORAGE_PUBLIC_URL"],
-		azure: ["STORAGE_BUCKET", "STORAGE_PUBLIC_URL"],
-		firebase: ["STORAGE_BUCKET", "STORAGE_PUBLIC_URL"]
-	},
-	optionKeys: [
-		"publicRead",
-		"prefix",
-		"account"
-	],
-	implicitDefault: false
-});
-registerResourceKind({
-	kind: "topic",
-	engines: ["jobs"],
-	defaultEngine: "jobs",
-	envBases: ["REBASE_TOPIC_URL"],
-	optionKeys: ["delivery", "maxAttempts"],
-	implicitDefault: false
-});
-//#endregion
-export { encodeRelationAggregateSort as _, RLS_UID_SQL as a, sortKeyToString as b, getDeclaredSubcollections as c, DEFAULT_DATA_SOURCE_KEY as d, getDataSourceCapabilities as f, REST_TO_CANONICAL as g, NULL_OPS as h, RLS_ROLES_SQL as i, isPostgresCollectionConfig as l, CANONICAL_TO_REST as m, LEGACY_RLS_SCHEMA as n, rewriteLegacyRlsFunctions as o, ALL_WHERE_FILTER_OPS as p, REBASE_SCHEMA as r, usesLegacyRlsFunctions as s, declaredDatabaseExtensions as t, isRelationalCollectionConfig as u, isRelationAggregateSort as v, toCanonicalOp as x, parseRelationAggregateSort as y };
-
-//# sourceMappingURL=src-DiB5RP2Z.js.map