@rebasepro/server-postgres 0.10.1-canary.b1e3dbf → 0.10.1-canary.ed8caed

package/dist/schema/ensure-collection-tables.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Bringing a database up to date with a bundle's collections, additively.
+ *
+ * ## Why this exists
+ *
+ * A managed runtime boots someone else's compiled project against a database it
+ * has never seen. Auth tables are ensured at boot already, but collection tables
+ * were not created by anything: the platform ran the app and every `/api/data/*`
+ * request answered 500 on a missing relation. `rebase db push` cannot help — it
+ * is an Atlas-driven CLI command, and the runtime image ships no CLI.
+ *
+ * ## Why additive-only, forever
+ *
+ * This runs unattended, against a database with customers' data in it, with no
+ * human reading a diff. So it may only ever do things that cannot lose data:
+ * create a missing table, add a missing column, create a missing enum type.
+ *
+ * It will **never** drop a table or a column, narrow a type, or alter a
+ * constraint. A removed field leaves its column behind; a renamed field looks
+ * like an addition and the old column stays. That is the correct trade for an
+ * automated path — the alternative is an unattended process that can silently
+ * destroy a column, which is precisely the failure `db push` was hardened
+ * against. Destructive changes stay a deliberate, human-reviewed migration.
+ *
+ * Because of that, this is safe to run on every boot, and re-running it is a
+ * no-op.
+ */
+import { type CollectionConfig } from "@rebasepro/types";
+/**
+ * The subset of a database handle this needs: run a statement, get rows back.
+ *
+ * Deliberately parameterless. Everything here is DDL or catalogue reads keyed by
+ * schema name, and schema names are identifiers — they cannot be bound as
+ * parameters anyway. They are validated against {@link SAFE_IDENTIFIER} before
+ * they reach a statement, so a config that somehow carried a quote is refused
+ * rather than concatenated.
+ */
+export interface Queryable {
+    query<T = unknown>(sql: string): Promise<{
+        rows: T[];
+    }>;
+}
+/** What the database currently has, as the planner needs it. */
+export interface ExistingSchema {
+    /** `schema.table` → set of column names. */
+    tables: Map<string, Set<string>>;
+    /** `schema.typename` of every enum type that already exists. */
+    enums: Set<string>;
+}
+export interface EnsureAction {
+    kind: "create-enum" | "create-table" | "add-column";
+    /** Qualified target, for logging: `public.posts` or `public.posts.title`. */
+    target: string;
+    sql: string;
+}
+export interface EnsurePlan {
+    actions: EnsureAction[];
+    /** Every statement, in dependency order. Empty when the schema is current. */
+    statements: string[];
+}
+/**
+ * Decide what to add. Pure — the caller supplies what exists and runs the result.
+ *
+ * Ordering matters and is deliberate: enum types before the tables and columns
+ * that reference them, tables before the columns added to other tables (a new
+ * table may be the target of a relation), and nothing is emitted twice.
+ */
+export declare function planCollectionSchemaEnsure(collections: CollectionConfig[], existing: ExistingSchema): EnsurePlan;
+/** Read what the database has, for the schemas the collections live in. */
+export declare function readExistingSchema(client: Queryable, schemas: string[]): Promise<ExistingSchema>;
+/**
+ * Bring the database up to date. Returns what it did.
+ *
+ * Each statement runs on its own rather than in one transaction: they are all
+ * independently safe and idempotent, and a single failure (an enum label that
+ * cannot be added, say) should not roll back the tables that were created fine.
+ * The error is surfaced with the statement that caused it.
+ */
+export declare function ensureCollectionTables(client: Queryable, collections: CollectionConfig[], log?: (message: string) => void): Promise<EnsurePlan>;

package/dist/schema/generate-postgres-ddl-logic.d.ts

@@ -1,4 +1,7 @@
-import { CollectionConfig } from "@rebasepro/types";
+import { CollectionConfig, Property } from "@rebasepro/types";
+export declare const resolveColumnName: (propName: string, prop?: Property | null) => string;
+export declare const isIdProperty: (propName: string, prop: Property, collection: CollectionConfig) => boolean;
+export declare const getSqlColumnType: (propName: string, prop: Property, collection: CollectionConfig, collections: CollectionConfig[]) => string;
 export declare const generatePostgresDdl: (collections: CollectionConfig[], options?: {
     includePolicies?: boolean;
 }) => Promise<string>;

package/dist/services/FetchService.d.ts

@@ -5,6 +5,7 @@ import type { VectorSearchParams } from "@rebasepro/types";
 import { RelationService } from "./RelationService";
 import { DrizzleClient } from "../interfaces";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+import { type NestedPathHop } from "./nested-path";
 /**
  * Service for handling all row read operations.
  * Handles fetching, searching, counting, and filtering rows.
@@ -65,6 +66,22 @@ export declare class FetchService {
      * Extract cursor pagination conditions from startAfter options.
      */
     private buildCursorConditions;
+    /**
+     * Compile "rows reachable from this parent" into a `WHERE` condition on the
+     * target table, so a nested listing can run as an ordinary collection query.
+     */
+    private buildRelationScope;
+    /**
+     * Whether `id` is actually reachable at `collectionPath`.
+     *
+     * Trivially true for a root path. For a nested one it is a real question:
+     * the path resolves to the target collection, and matching on the primary
+     * key alone made the parent segment decorative — `authors/1/posts/43`
+     * returned post 43 whoever wrote it, and the REST layer's delete then
+     * deleted it. A row that is not under this parent is reported as absent,
+     * which is what a caller addressing it through the parent should see.
+     */
+    private isAddressableUnder;
     /**
      * Fetch a single row by ID
      */
@@ -83,6 +100,8 @@ export declare class FetchService {
         databaseId?: string;
         vectorSearch?: VectorSearchParams;
         logical?: LogicalCondition;
+        /** Narrow to the rows reachable from a parent through a relation. */
+        relatedTo?: NestedPathHop;
     }): Promise<Record<string, unknown>[]>;
     /**
      * Fallback path used when db.query is unavailable.
@@ -118,10 +137,6 @@ export declare class FetchService {
         limit?: number;
         databaseId?: string;
     }): Promise<Record<string, unknown>[]>;
-    /**
-     * Fetch collection from multi-segment path
-     */
-    private fetchCollectionFromPath;
     /**
      * Count rows in a collection
      */
@@ -130,10 +145,6 @@ export declare class FetchService {
         searchString?: string;
         databaseId?: string;
     }): Promise<number>;
-    /**
-     * Count rows from multi-segment path
-     */
-    private countEntitiesFromPath;
     /**
      * Check if a field value is unique
      */
@@ -160,6 +171,8 @@ export declare class FetchService {
         searchString?: string;
         databaseId?: string;
         vectorSearch?: VectorSearchParams;
+        /** Narrow to the rows reachable from a parent through a relation. */
+        relatedTo?: NestedPathHop;
     }, include?: string[]): Promise<Record<string, unknown>[]>;
     /**
      * Fetch a single row with optional relation includes for REST API.

package/dist/services/PersistService.d.ts

@@ -38,6 +38,18 @@ export declare class PersistService {
      * Delete all rows from a collection
      */
     deleteAll(collectionPath: string, _databaseId?: string): Promise<void>;
+    /**
+     * The column on the *target* table that records the parent, for a create
+     * under a nested one-to-many path.
+     *
+     * Returns `undefined` when the link is not a column at all (a multi-hop
+     * `joinPath`), so the caller writes the row without stamping anything.
+     *
+     * `relation.localKey` is deliberately not consulted: it names a column on
+     * the *source* table. Falling back to it here — which is what this used to
+     * do, and first — stamped the parent's own foreign key onto the child row.
+     */
+    private resolveParentForeignKeyColumn;
     /**
      * Save an row (create or update)
      *

package/dist/services/RelationService.d.ts

@@ -1,6 +1,7 @@
 import { DrizzleClient } from "../interfaces";
 import { CollectionConfig, FilterValues, Relation } from "@rebasepro/types";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+import type { NestedPathHop } from "./nested-path";
 /**
  * Service for handling all relation-related operations.
  * Handles fetching, updating, and managing row relations.
@@ -85,6 +86,35 @@ export declare class RelationService {
         filter?: FilterValues<Extract<keyof M, string>>;
         databaseId?: string;
     }): Promise<number>;
+    /**
+     * Count the target rows a parent reaches through `relation`, narrowed by
+     * `additionalFilters` (conditions on the target table).
+     *
+     * Shared by the public count and by {@link isRelated}, so "how many children
+     * does this parent have" and "is this row one of them" are answered by the
+     * same join — a membership test that reconstructed the join separately would
+     * be free to disagree with the listing it is supposed to gate.
+     */
+    private countRelatedRows;
+    /**
+     * Whether `targetId` is actually reachable from the parent named in `hop`.
+     *
+     * A nested address like `authors/1/posts/43` used to resolve to the target
+     * collection and then match on the primary key alone, so the parent segment
+     * decided nothing: the row came back, and was updated or deleted, whoever it
+     * belonged to. Reads, updates and deletes now all gate on this.
+     */
+    isRelated(hop: NestedPathHop, targetId: string | number): Promise<boolean>;
+    /**
+     * Remove the junction row linking a parent to `targetId`, leaving the target
+     * row itself alone.
+     *
+     * This is what `DELETE authors/1/tags/5` has to mean for a many-to-many: the
+     * target is shared, so deleting the row would remove the tag from every other
+     * post that uses it. It used to do exactly that — resolve the path to the
+     * `tags` table and delete by primary key.
+     */
+    unlinkRelatedEntity(tx: DrizzleClient, hop: NestedPathHop, targetId: string | number): Promise<void>;
     /**
      * Batch fetch related rows for multiple parent rows to avoid N+1 queries
      */

package/dist/services/nested-path.d.ts

@@ -0,0 +1,59 @@
+import { CollectionConfig, Relation } from "@rebasepro/types";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+/**
+ * The last hop of a nested collection path, e.g. `authors/1/posts`.
+ *
+ * The walk that produces this was written out four separate times — in
+ * `FetchService.fetchCollectionFromPath`, `FetchService.countEntitiesFromPath`,
+ * `PersistService.save` and `CollectionRegistry.getCollectionByPath` — and had
+ * drifted, so the read path and the write path did not agree on which relation
+ * a path named. It lives here once now.
+ */
+export interface NestedPathHop {
+    /** The collection the final relation is declared on (e.g. `authors`). */
+    parentCollection: CollectionConfig;
+    /** The parent's id as it appeared in the path, unparsed. */
+    parentId: string;
+    /** The path segment that named the relation (e.g. `posts`). */
+    relationKey: string;
+    relation: Relation;
+    /** `relation.target()`, resolved once. */
+    targetCollection: CollectionConfig;
+}
+/**
+ * True when `path` addresses rows through a relation rather than a root
+ * collection.
+ *
+ * Any separator at all counts — a root collection slug never contains one — so
+ * a malformed path like `collection/id` is a *broken* nested path and gets
+ * reported as one by {@link resolveNestedPath}, rather than being looked up as
+ * a root collection whose slug happens to contain a slash.
+ */
+export declare function isNestedPath(path: string): boolean;
+export declare function splitPathSegments(path: string): string[];
+/**
+ * Walk a nested collection path down to the relation it ends in.
+ *
+ * Returns `undefined` for a plain root-collection path so callers can keep the
+ * root case on its existing code path. Throws when the path is malformed, or
+ * when a segment names a relation that does not exist — the same errors the
+ * individual walks used to raise, with the available names attached.
+ */
+export declare function resolveNestedPath(path: string, registry: PostgresCollectionRegistry): NestedPathHop | undefined;
+/**
+ * A relation reached through a junction table — many-to-many, or a multi-hop
+ * `joinPath`. The target row is shared with other parents, so writing "through"
+ * such a path addresses the *link*, not the row.
+ */
+export declare function isJunctionBackedRelation(relation: Relation): boolean;
+/**
+ * Reject a nested write whose final segment is a to-one relation.
+ *
+ * There is no column on the target row that records a to-one parent — the
+ * foreign key lives on the *parent* table. The write path used to fall through
+ * to `relation.localKey` here and stamp the parent's own FK column onto the
+ * target row, which either raised an opaque "column does not exist" or, when a
+ * column of that name happened to exist on the target, silently wrote the wrong
+ * one.
+ */
+export declare function assertWritableThrough(hop: NestedPathHop, path: string): void;

package/dist/src-CBgtrPhJ.js

@@ -0,0 +1,336 @@
+import { createRequire as __createRequire } from "module";
+import "process";
+__createRequire(import.meta.url);
+//#region ../types/src/types/entities.ts
+/**
+* Class used to create a reference to a entity in a different path
+*/
+var EntityRelation = class {
+	__type = "relation";
+	/**
+	* ID of the entity
+	*/
+	id;
+	/**
+	* A string representing the path of the referenced document (relative
+	* to the root of the database).
+	*/
+	path;
+	/**
+	* Pre-fetched data payload to eliminate N+1 queries.
+	* When present, clients can use this directly instead of fetching.
+	*/
+	data;
+	constructor(id, path, data) {
+		this.id = id;
+		this.path = path;
+		this.data = data;
+	}
+	get pathWithId() {
+		return `${this.path}/${this.id}`;
+	}
+	isEntityReference() {
+		return false;
+	}
+	isEntityRelation() {
+		return true;
+	}
+};
+var Vector = class {
+	value;
+	constructor(value) {
+		this.value = value;
+	}
+};
+//#endregion
+//#region ../types/src/types/filter-operators.ts
+/** 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 = 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);
+/**
+* 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_TO_CANONICAL[op];
+}
+//#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";
+}
+/**
+* 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/policy.ts
+/**
+* The id a request without a logged-in user reports as `auth.uid()`.
+*
+* A user-context request always sets `app.uid`: blank would read back as
+* `NULL`, and `NULL` is how the trusted server context is recognised, so an
+* anonymous visitor would be promoted to server privileges. The driver
+* therefore substitutes this sentinel at the single chokepoint where the GUC
+* is set.
+*
+* The consequence for policy authors is that **`auth.uid() IS NOT NULL` is a
+* tautology on the user path** — it is true for anonymous visitors too. Use
+* {@link policy.authenticated} (or `auth.uid() <> 'anonymous'`) to mean "signed
+* in", and {@link policy.serverContext} to mean "the trusted server context".
+*
+* @group Models
+*/
+var ANONYMOUS_USER_ID = "anonymous";
+/** @group Models */
+var policy = {
+	true: () => ({ kind: "true" }),
+	false: () => ({ kind: "false" }),
+	and: (...operands) => ({
+		kind: "and",
+		operands
+	}),
+	or: (...operands) => ({
+		kind: "or",
+		operands
+	}),
+	not: (operand) => ({
+		kind: "not",
+		operand
+	}),
+	compare: (left, op, right) => ({
+		kind: "compare",
+		op,
+		left,
+		right
+	}),
+	rolesOverlap: (roles) => ({
+		kind: "rolesOverlap",
+		roles
+	}),
+	rolesContain: (roles) => ({
+		kind: "rolesContain",
+		roles
+	}),
+	authenticated: () => ({ kind: "authenticated" }),
+	serverContext: () => ({ kind: "serverContext" }),
+	existsIn: (args) => ({
+		kind: "existsIn",
+		collection: args.collection,
+		where: args.where
+	}),
+	raw: (sql) => ({
+		kind: "raw",
+		sql
+	}),
+	field: (name) => ({
+		kind: "field",
+		name
+	}),
+	outerField: (name) => ({
+		kind: "outerField",
+		name
+	}),
+	literal: (value) => ({
+		kind: "literal",
+		value
+	}),
+	authUid: () => ({ kind: "authUid" }),
+	authRoles: () => ({ kind: "authRoles" })
+};
+//#endregion
+//#region ../types/src/types/backend.ts
+/**
+* Type guard: does this admin support SQL operations?
+* @group Admin
+*/
+function isSQLAdmin(admin) {
+	return !!admin && typeof admin.executeSql === "function";
+}
+/**
+* Type guard: does this admin support schema management?
+* @group Admin
+*/
+function isSchemaAdmin(admin) {
+	return !!admin && (typeof admin.fetchUnmappedTables === "function" || typeof admin.fetchTableMetadata === "function");
+}
+//#endregion
+//#region ../types/src/types/channel_bus.ts
+/**
+* Whether `setting` is an already-constructed transport rather than a request
+* for a built-in one.
+*
+* Structural rather than nominal so that an instance from a *different copy* of
+* `@rebasepro/types` — an entirely normal outcome of a separately versioned
+* transport package — is still recognised.
+*/
+function isChannelBusInstance(setting) {
+	return typeof setting?.publish === "function";
+}
+//#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)";
+/** @group Models */
+var POSTGRES_CAPABILITIES = {
+	key: "postgres",
+	label: "PostgreSQL",
+	supportsRelations: true,
+	supportsSubcollections: false,
+	supportsRLS: true,
+	supportsReferences: false,
+	supportsColumnTypes: true,
+	supportsRealtime: true,
+	filterOperators: ALL_WHERE_FILTER_OPS,
+	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,
+	filterOperators: ALL_WHERE_FILTER_OPS.filter((op) => op !== "like" && op !== "ilike" && op !== "not-like" && op !== "not-ilike"),
+	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,
+	filterOperators: ALL_WHERE_FILTER_OPS,
+	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,
+	filterOperators: ALL_WHERE_FILTER_OPS,
+	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
+export { isSchemaAdmin as a, getDeclaredSubcollections as c, REST_TO_CANONICAL as d, toCanonicalOp as f, isSQLAdmin as i, isPostgresCollectionConfig as l, Vector as m, getDataSourceCapabilities as n, ANONYMOUS_USER_ID as o, EntityRelation as p, isChannelBusInstance as r, policy as s, DEFAULT_DATA_SOURCE_KEY as t, NULL_OPS as u };
+
+//# sourceMappingURL=src-CBgtrPhJ.js.map