@rebasepro/server-postgres 0.14.0 → 0.14.1

package/dist/PostgresBackendDriver.d.ts

@@ -152,7 +152,7 @@ export declare class PostgresBackendDriver implements DataDriver {
     delete<M extends Record<string, unknown>>({ row, collection }: DeleteProps<M>): Promise<void>;
     deleteAll(path: string): Promise<void>;
     checkUniqueField(path: string, name: string, value: unknown, id?: string, collection?: CollectionConfig): Promise<boolean>;
-    count<M extends Record<string, unknown>>({ path, collection, filter, logical, searchString }: FetchCollectionProps<M>): Promise<number>;
+    count<M extends Record<string, unknown>>({ path, collection, filter, logical, searchString, vectorSearch }: FetchCollectionProps<M>): Promise<number>;
     private getTargetDb;
     executeSql(sqlText: string, options?: {
         database?: string;

package/dist/PostgresBootstrapper.d.ts

@@ -89,6 +89,25 @@ export interface PostgresDriverInternals {
  * and this is the part that was wrong.
  */
 export declare function resolveDriftCheckName(col: CollectionConfig, registeredTableNames: string[]): string;
+/**
+ * Why the tables this backend serves are not in the database — the part of the
+ * drift warning that has to be true rather than merely plausible.
+ *
+ * The three answers need three different actions, and only the caller knows
+ * which one applies. This warning used to assert the first ("this runtime
+ * applies the collection schema at boot unless REBASE_MIGRATE_ON_BOOT=none")
+ * and then point at that variable and at driver-version skew. For an app whose
+ * boot path contained no provisioning step at all, every word of that was a
+ * dead end: nothing read the variable, and the driver was current. The advice
+ * cost an investigation, which is a strictly worse outcome than saying less.
+ *
+ * Exported for its own test: the surrounding check needs a live pool and a real
+ * database, and this is the part that was wrong.
+ */
+export declare function describeSchemaDriftCause(provisioning: {
+    attempted: boolean;
+    reason?: string;
+} | undefined): string[];
 /**
  * Is this the local database `rebase init` scaffolds — i.e. the one case where
  * "you are connected as a superuser" is not news?

package/dist/auth/services.d.ts

@@ -58,6 +58,16 @@ export declare class UserService implements UserRepository {
     private withServerContext;
     private mapRowToUser;
     private mapPayload;
+    /**
+     * @see UserRepository.createUser — an email already in use is a 409.
+     *
+     * The route checks first and answers 409; this is the same answer for the
+     * requests that get past the check, which two clicks on a signup button
+     * are enough to produce. `PersistService` has mapped `23505` to a conflict
+     * for collection writes since the layer that holds the SQLSTATE was made
+     * responsible for saying whose fault a failure is; the auth writes never
+     * got the same treatment and reached the client as "Internal Server Error".
+     */
     createUser(data: CreateUserData): Promise<UserData>;
     getUserById(id: string): Promise<UserData | null>;
     getUserByEmail(email: string): Promise<UserData | null>;

package/dist/{auth-users-columns-BfQHf9JE.js → auth-users-columns-C-FDnL_e.js}

@@ -2505,8 +2505,147 @@ function schemaOf(collection) {
 }
 function resolveColumnName(propName, collection) {
 	const prop = collection?.properties?.[propName];
-	if (prop && "columnName" in prop && typeof prop.columnName === "string") return prop.columnName;
-	return toSnakeCase(propName);
+	if (prop && "columnName" in prop && typeof prop.columnName === "string") return quoteColumnIdentifier(prop.columnName);
+	return quoteColumnIdentifier(toSnakeCase(propName));
+}
+/**
+* Every PostgreSQL keyword that cannot stand as a bare column reference.
+* Appendix C's two reserved categories — plain "reserved", and "reserved (can
+* be function or type name)" — since neither may name a column unquoted.
+*/
+var RESERVED_SQL_WORDS = /* @__PURE__ */ new Set([
+	"all",
+	"analyse",
+	"analyze",
+	"and",
+	"any",
+	"array",
+	"as",
+	"asc",
+	"asymmetric",
+	"authorization",
+	"binary",
+	"both",
+	"case",
+	"cast",
+	"check",
+	"collate",
+	"collation",
+	"column",
+	"concurrently",
+	"constraint",
+	"create",
+	"cross",
+	"current_catalog",
+	"current_date",
+	"current_role",
+	"current_schema",
+	"current_time",
+	"current_timestamp",
+	"current_user",
+	"default",
+	"deferrable",
+	"desc",
+	"distinct",
+	"do",
+	"else",
+	"end",
+	"except",
+	"false",
+	"fetch",
+	"for",
+	"foreign",
+	"freeze",
+	"from",
+	"full",
+	"grant",
+	"group",
+	"having",
+	"ilike",
+	"in",
+	"initially",
+	"inner",
+	"intersect",
+	"into",
+	"is",
+	"isnull",
+	"join",
+	"lateral",
+	"leading",
+	"left",
+	"like",
+	"limit",
+	"localtime",
+	"localtimestamp",
+	"natural",
+	"not",
+	"notnull",
+	"null",
+	"offset",
+	"on",
+	"only",
+	"or",
+	"order",
+	"outer",
+	"overlaps",
+	"placing",
+	"primary",
+	"references",
+	"returning",
+	"right",
+	"select",
+	"session_user",
+	"similar",
+	"some",
+	"symmetric",
+	"system_user",
+	"table",
+	"tablesample",
+	"then",
+	"to",
+	"trailing",
+	"true",
+	"union",
+	"unique",
+	"user",
+	"using",
+	"variadic",
+	"verbose",
+	"when",
+	"where",
+	"window",
+	"with"
+]);
+/** An identifier Postgres reads back unchanged without quotes. */
+var BARE_IDENTIFIER = /^[a-z_][a-z0-9_$]*$/;
+/**
+* Quote a column reference when Postgres would not read the bare name as that
+* column — and only then.
+*
+* Three ways a bare name goes wrong, in ascending order of how long it takes to
+* notice:
+*
+* - **Case.** `columnName` is used verbatim, and `rebase schema introspect`
+*   populates it from a live database, so a legacy `"createdAt"` column arrives
+*   spelled exactly that way. Unquoted, Postgres folds it to `createdat` and
+*   `CREATE POLICY` fails with "column does not exist" — the collection keeps
+*   RLS enabled with no policy, which denies every row.
+* - **Syntax.** A column named `order` or `default` is a syntax error mid-clause.
+* - **Silent rebinding.** `user`, `current_user`, `session_user`, `current_date`
+*   and friends are *valid bare expressions*, so the policy compiles, applies,
+*   and is reported as a success — while comparing against the connected role
+*   or the wall clock instead of the column. Under RLS every request runs as the
+*   same `rebase_user` role, so `USING (user = rebase.uid())` is a constant: it
+*   denies everything, and its negation admits everything.
+*
+* Only the names that need it are quoted, so an ordinary snake_case policy body
+* is emitted byte-for-byte as before. That keeps generated artifacts and the
+* policies already stored in shipped databases stable — this fix reaches the
+* clauses that were broken and no others.
+*/
+function quoteColumnIdentifier(name) {
+	if (BARE_IDENTIFIER.test(name) && !RESERVED_SQL_WORDS.has(name)) return name;
+	return `"${name.replace(/"/g, "\"\"")}"`;
 }
 function quoteLiteral(value) {
 	if (value === null) return "NULL";
@@ -3867,6 +4006,90 @@ var CollectionRegistry = class {
 	}
 };
 //#endregion
+//#region ../common/src/data/sort-dialect.ts
+/**
+* Sort-order wire codec.
+*
+* This is the ONLY module that knows about the colon-delimited wire format
+* (`"field:direction"`) used in HTTP query parameters, and about the JSON-array
+* form that carries a multi-column sort over the same parameter.
+* Everything else speaks {@link OrderByTuple} exclusively.
+*
+* Mirrors the filter architecture in `filter-dialect.ts`.
+*
+* @module
+*/
+/**
+* Collapse the one-key and many-key spellings of a sort into the list form.
+*
+* `["a", "desc"]` and `[["a", "desc"]]` mean the same thing and normalize to
+* the same value; the two are told apart by whether the first element is
+* itself an array, which no field name ever is.
+*
+* @returns The keys in order of significance, or `undefined` for no sort. An
+*   empty list also returns `undefined` — "sort by nothing" is no sort, and
+*   letting `[]` through would have every layer below re-deciding what it meant.
+*/
+function normalizeOrderBy(orderBy) {
+	if (!orderBy || orderBy.length === 0) return void 0;
+	const list = Array.isArray(orderBy[0]) ? orderBy : [orderBy];
+	return list.length > 0 ? list : void 0;
+}
+/**
+* Collapse the driver-level `{orderBy, order}` pair into the list form.
+*
+* The driver contract spells a single-column sort as a field name plus a
+* separate direction, and a multi-column one as a list of tuples that leaves
+* `order` meaningless. Every driver reads both through here so neither
+* spelling has to be handled twice.
+*
+* An absent direction means ascending — the same thing a bare `?orderBy=name`
+* has always meant over HTTP. The Postgres driver used to read the same pair as
+* *descending* while Mongo read it as ascending, so one field name and no
+* direction described two different queries depending on which database was
+* underneath. Neither had a caller: every path in the workspace passes a
+* direction, which is why the disagreement went unnoticed rather than being
+* load-bearing.
+*/
+function normalizeDriverOrderBy(orderBy, order) {
+	if (!orderBy) return void 0;
+	if (typeof orderBy === "string") return [[orderBy, order === "desc" ? "desc" : "asc"]];
+	return orderBy.length > 0 ? orderBy : void 0;
+}
+/** A sort whose *shape* is unusable, as opposed to one naming a field that does not exist. */
+var OrderBySpecError = class extends Error {
+	code = "INVALID_ORDER_BY";
+	constructor(detail) {
+		super(`Invalid \`orderBy\`: ${detail}. Expected a field name, or a list of [field, direction] pairs like [["roles","asc"],["created_at","desc"]]`);
+		this.name = "OrderBySpecError";
+	}
+};
+/**
+* Validate an `orderBy` that arrived from outside this process — a WebSocket
+* subscribe frame, a driver call from untyped JavaScript — and return it in the
+* list form.
+*
+* Strict on purpose, in the same way the REST `parseOrderByParam` is: the
+* failure mode for a shape nobody checks is not a crash but a *silently
+* different query*. A malformed entry read as a field name resolves to no
+* column, and under the lenient unknown-field mode the sort is then dropped and
+* the rows come back in whatever order the database pleased — sorted, as far as
+* the subscriber can tell, by whatever they asked for.
+*/
+function parseOrderBySpecStrict(raw, order) {
+	if (raw === void 0 || raw === null || raw === "") return void 0;
+	if (typeof raw === "string") return normalizeDriverOrderBy(raw, order);
+	if (!Array.isArray(raw) || raw.length === 0) throw new OrderBySpecError(`${typeof raw} is not a field name or a list of sort keys`);
+	if (typeof raw[0] === "string") return [toStrictTuple(raw, 0)];
+	return raw.map(toStrictTuple);
+}
+function toStrictTuple(raw, index) {
+	if (!Array.isArray(raw) || typeof raw[0] !== "string" || raw[0].trim() === "") throw new OrderBySpecError(`entry ${index} has no field name`);
+	const direction = raw[1];
+	if (direction !== void 0 && direction !== "asc" && direction !== "desc") throw new OrderBySpecError(`entry ${index} has direction '${String(direction)}'`);
+	return [raw[0], direction ?? "asc"];
+}
+//#endregion
 //#region ../common/src/data/query_builder.ts
 var QueryBuilder = class {
 	collection;
@@ -3895,11 +4118,18 @@ var QueryBuilder = class {
 	}
 	/**
 	* Order the results by a specific column.
+	*
+	* Called again, this adds a tie-breaker rather than replacing the sort:
+	* keys apply in the order they were added.
+	*
 	* @example
 	* client.collection('users').orderBy('createdAt', 'desc').find()
+	* @example
+	* client.collection('users').orderBy('roles').orderBy('createdAt', 'desc').find()
 	*/
 	orderBy(column, direction = "asc") {
-		this.params.orderBy = [column, direction];
+		const existing = normalizeOrderBy(this.params.orderBy) ?? [];
+		this.params.orderBy = [...existing, [column, direction]];
 		return this;
 	}
 	/**
@@ -4073,9 +4303,10 @@ async function* paginateFind(find, params, label = "collection") {
 	const requestedDirection = typeof cursor === "object" && cursor !== null ? cursor.direction : void 0;
 	let direction = "asc";
 	if (cursorField) {
-		const orderBy = findParams.orderBy;
-		if (orderBy && orderBy[0] !== cursorField) throw new RebasePaginationError("cursor-order-mismatch", `Cannot seek on "${cursorField}" while ordering "${label}" by "${orderBy[0]}": keyset pagination only advances along the column the query is sorted by. Order by "${cursorField}", or drop the cursor and page by offset.`);
-		direction = requestedDirection ?? orderBy?.[1] ?? "asc";
+		const orderBy = normalizeOrderBy(findParams.orderBy);
+		if (orderBy && orderBy.length > 1) throw new RebasePaginationError("cursor-order-mismatch", `Cannot seek on "${cursorField}" while ordering "${label}" by ${orderBy.map(([field]) => `"${field}"`).join(", ")}: keyset pagination advances along a single column. Order by "${cursorField}" alone, or drop the cursor and page by offset.`);
+		if (orderBy && orderBy[0][0] !== cursorField) throw new RebasePaginationError("cursor-order-mismatch", `Cannot seek on "${cursorField}" while ordering "${label}" by "${orderBy[0][0]}": keyset pagination only advances along the column the query is sorted by. Order by "${cursorField}", or drop the cursor and page by offset.`);
+		direction = requestedDirection ?? orderBy?.[0][1] ?? "asc";
 		findParams.orderBy = [cursorField, direction];
 	}
 	const seekOp = direction === "desc" ? "<" : ">";
@@ -4552,8 +4783,7 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 				logical: params?.logical,
 				limit,
 				offset: driverOffset,
-				orderBy: params?.orderBy?.[0],
-				order: params?.orderBy?.[1],
+				orderBy: normalizeOrderBy(params?.orderBy),
 				searchString: params?.searchString
 			}, params?.include) : await driver.fetchCollection({
 				path: slug,
@@ -4561,8 +4791,7 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 				offset: driverOffset,
 				filter,
 				logical: params?.logical,
-				orderBy: params?.orderBy?.[0],
-				order: params?.orderBy?.[1],
+				orderBy: normalizeOrderBy(params?.orderBy),
 				searchString: params?.searchString
 			});
 			let total = rows.length + offset;
@@ -4657,8 +4886,7 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 				offset: driverOffset,
 				filter: params?.where,
 				logical: params?.logical,
-				orderBy: params?.orderBy?.[0],
-				order: params?.orderBy?.[1],
+				orderBy: normalizeOrderBy(params?.orderBy),
 				searchString: params?.searchString,
 				searchExplain: params?.searchExplain,
 				onUpdate: (entities) => {
@@ -4778,8 +5006,10 @@ var SdkQueryBuilder = class {
 		}
 		return this;
 	}
+	/** Called again, this adds a tie-breaker rather than replacing the sort. */
 	orderBy(column, direction = "asc") {
-		this.params.orderBy = [column, direction];
+		const existing = normalizeOrderBy(this.params.orderBy) ?? [];
+		this.params.orderBy = [...existing, [column, direction]];
 		return this;
 	}
 	limit(count) {
@@ -5430,6 +5660,6 @@ function isAuthCollection(collection) {
 	return typeof auth === "object" && auth !== null && auth.enabled === true;
 }
 //#endregion
-export { DEFAULT_ONE_OF_TYPE as $, getEnumVarName as A, createRelationRefWithData as B, getEffectiveSecurityRules as C, fieldKeyForColumn as D, findAnonymousGrants as E, getDeclaredPrimaryKeys as F, legacyForeignKeyName as G, updateDateAutoValues as H, isAddressableId as I, getPolicyNamesForRule as J, toPostgresIdentifier as K, parseIdValues as L, getTableVarName as M, resolveCollectionRelations as N, findRelation as O, buildCompositeId as P, toSnakeCase as Q, sortCollectionsBySlug as R, resolveJunctionSpecs as S, securityRuleToConditions as T, firstFreeKey as U, normalizeToEntityRelation as V, generateForeignKeyName as W, mergeDeep as X, isPrototypePollutingKey as Y, camelCase as Z, CollectionRegistry as _, SEARCH_STAMP_PREFIX as a, getJunctionCollectionConfig as b, assertSearchIsPostgresOnly as c, searchColumnStamps as d, DEFAULT_ONE_OF_VALUE as et, searchExtensionStatements as f, buildSdkData as g, visibleColumnProjection as h, isAuthCollection as i, getTableName as j, getColumnName as k, buildSearchColumnSpec as l, searchIndexStatements as m, authUsersColumnDefinition as n, isManyToMany as nt, SEARCH_TEXT_FN as o, searchHelperFunctions as p, toWireKey as q, authUsersColumnSql as r, Vector as rt, SEARCH_UNACCENT_FN as s, AUTH_USERS_COLUMNS as t, hasForeignKeyOnTarget as tt, hiddenColumnsOption as u, relationalCollections as v, policyToPostgres as w, getJunctionSecurityRules as x, resolveStringColumnLength as y, createRelationRef as z };
+export { mergeDeep as $, fieldKeyForColumn as A, parseIdValues as B, getJunctionCollectionConfig as C, policyToPostgres as D, getEffectiveSecurityRules as E, getTableVarName as F, updateDateAutoValues as G, createRelationRef as H, resolveCollectionRelations as I, legacyForeignKeyName as J, firstFreeKey as K, buildCompositeId as L, getColumnName as M, getEnumVarName as N, securityRuleToConditions as O, getTableName as P, isPrototypePollutingKey as Q, getDeclaredPrimaryKeys as R, resolveStringColumnLength as S, resolveJunctionSpecs as T, createRelationRefWithData as U, sortCollectionsBySlug as V, normalizeToEntityRelation as W, toWireKey as X, toPostgresIdentifier as Y, getPolicyNamesForRule as Z, OrderBySpecError as _, SEARCH_STAMP_PREFIX as a, isManyToMany as at, CollectionRegistry as b, assertSearchIsPostgresOnly as c, searchColumnStamps as d, camelCase as et, searchExtensionStatements as f, buildSdkData as g, visibleColumnProjection as h, isAuthCollection as i, hasForeignKeyOnTarget as it, findRelation as j, findAnonymousGrants as k, buildSearchColumnSpec as l, searchIndexStatements as m, authUsersColumnDefinition as n, DEFAULT_ONE_OF_TYPE as nt, SEARCH_TEXT_FN as o, Vector as ot, searchHelperFunctions as p, generateForeignKeyName as q, authUsersColumnSql as r, DEFAULT_ONE_OF_VALUE as rt, SEARCH_UNACCENT_FN as s, AUTH_USERS_COLUMNS as t, toSnakeCase as tt, hiddenColumnsOption as u, normalizeDriverOrderBy as v, getJunctionSecurityRules as w, relationalCollections as x, parseOrderBySpecStrict as y, isAddressableId as z };
 
-//# sourceMappingURL=auth-users-columns-BfQHf9JE.js.map
+//# sourceMappingURL=auth-users-columns-C-FDnL_e.js.map