@rebasepro/server-postgres 0.12.1-canary.g386667d → 0.12.1-canary.g4e7bcbf

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

@@ -56,7 +56,7 @@ export interface ExistingSchema {
     constraints?: Set<string>;
 }
 export interface EnsureAction {
-    kind: "create-enum" | "create-table" | "add-column" | "add-constraint";
+    kind: "create-enum" | "create-table" | "add-column" | "add-constraint" | "rename-column";
     /** Qualified target, for logging: `public.posts` or `public.posts.title`. */
     target: string;
     sql: string;
@@ -65,6 +65,26 @@ export interface EnsurePlan {
     actions: EnsureAction[];
     /** Every statement, in dependency order. Empty when the schema is current. */
     statements: string[];
+    /**
+     * Relation columns this plan is about to create where the table already
+     * carries the same column under its pre-singularization name.
+     *
+     * The reason this is reported rather than silently handled: the ensure is
+     * additive, so it would add `category_id` beside a populated
+     * `categorie_id` and the relation would then read the new, empty one. No
+     * statement fails, no table is missing, and the only symptom is relations
+     * resolving to nothing — which is indistinguishable from having no data.
+     */
+    legacyForeignKeys: LegacyForeignKey[];
+}
+/** A relation column whose old and new spellings both plausibly apply. */
+export interface LegacyForeignKey {
+    /** `schema.table`. */
+    table: string;
+    /** The name the current rule derives, and what this plan would create. */
+    expected: string;
+    /** The name the old rule derived, which the table already has. */
+    legacy: string;
 }
 export interface EnsureOutcome extends EnsurePlan {
     /**

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

@@ -19,6 +19,15 @@ type ResolveCollection = (slug: string) => CollectionConfig | undefined;
  * multiple commands in one execute), while `db push` writes the joined string.
  */
 export declare const generatePolicyStatements: (collection: CollectionConfig, rule: SecurityRule, resolveCollection: ResolveCollection) => string[];
+/**
+ * Single-quote escaping for a SQL string literal (PostgreSQL doubles the
+ * quote). Enum labels come straight from user-authored collection config, so a
+ * label like `it's` closes the literal early and the whole generated file stops
+ * parsing at the `CREATE TYPE`. Lives here rather than next to its other caller
+ * because ensure-collection-tables already imports from this module — the
+ * reverse would be a cycle.
+ */
+export declare const quoteSqlLiteral: (value: string) => string;
 export declare const getSqlColumnType: (propName: string, prop: Property, collection: CollectionConfig, collections: CollectionConfig[]) => string;
 export declare const generatePostgresDdl: (collections: CollectionConfig[], options?: {
     includePolicies?: boolean;
@@ -52,6 +61,15 @@ export interface RelationalColumnPlan {
     type: string;
     /** Absent when the target collection is not part of this bundle. */
     foreignKey?: ForeignKeyPlan;
+    /**
+     * What this column would have been called before `generateForeignKeyName`
+     * learned to singularize — set only when the two differ and the column name
+     * is the derived default rather than one the author wrote.
+     *
+     * Carried so the boot-time ensure can notice a database provisioned under
+     * the old rule. It is never used to name anything.
+     */
+    legacyColumn?: string;
 }
 /** The table behind a many-to-many `through` relation. */
 export interface JunctionTablePlan {
@@ -61,6 +79,7 @@ export interface JunctionTablePlan {
     columns: {
         name: string;
         type: string;
+        legacyName?: string;
     }[];
     /** Both endpoint columns plus the composite primary key. */
     createTable: string;

package/dist/services/FetchService.d.ts

@@ -141,7 +141,7 @@ export declare class FetchService {
     /**
      * Fallback path used when db.query is unavailable.
      *
-     * The primary path runs the results through `toCmsRow`, which maps
+     * The primary path runs the results through `toFlatRow`, which maps
      * relations from what drizzle already nested — no query per row. This one
      * has no nesting to read, so it resolves relations itself, in batches.
      *
@@ -177,6 +177,7 @@ export declare class FetchService {
      */
     count<M extends Record<string, unknown>>(collectionPath: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
+        logical?: LogicalCondition;
         searchString?: string;
         databaseId?: string;
     }): Promise<number>;
@@ -198,6 +199,8 @@ export declare class FetchService {
      */
     fetchCollectionForRest<M extends Record<string, unknown>>(collectionPath: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
+        /** An `or(...)`/`and(...)` group, applied alongside `filter`. */
+        logical?: LogicalCondition;
         orderBy?: string;
         order?: "desc" | "asc";
         limit?: number;

package/dist/services/dataService.d.ts

@@ -1,4 +1,4 @@
-import { FilterValues } from "@rebasepro/types";
+import { FilterValues, LogicalCondition } from "@rebasepro/types";
 import type { VectorSearchParams } from "@rebasepro/types";
 import { FetchService } from "./FetchService";
 import { PersistService } from "./PersistService";
@@ -60,6 +60,8 @@ export declare class DataService implements DataRepository {
      */
     count<M extends Record<string, unknown>>(collectionPath: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
+        /** An `or(...)`/`and(...)` group, applied alongside `filter`. */
+        logical?: LogicalCondition;
         searchString?: string;
         databaseId?: string;
     }): Promise<number>;

package/dist/services/row-pipeline.d.ts

@@ -47,7 +47,7 @@ export declare function relationTargetAddress(targetRow: Record<string, unknown>
  * expects real types. The row's own address is *not* among the columns — it is
  * derived by the consumer from the collection's primary keys.
  */
-export declare function toCmsRow(row: Record<string, unknown>, collection: CollectionConfig, registry: PostgresCollectionRegistry): Record<string, unknown>;
+export declare function toFlatRow(row: Record<string, unknown>, collection: CollectionConfig, registry: PostgresCollectionRegistry): Record<string, unknown>;
 /**
  * The row REST serves: every column under its own name, with the value Postgres
  * returned, and relations inlined as the target's columns.

package/dist/{src-C_NHNVW2.js → src-BkdpiQdw.js}

@@ -1067,16 +1067,12 @@ function removeFunctions(o) {
 	if (o === void 0) return void 0;
 	if (o === null) return null;
 	if (typeof o === "object") {
-		if (Array.isArray(o)) return o.map((v) => removeFunctions(v));
+		if (Array.isArray(o)) return o.filter((v) => typeof v !== "function").map((v) => removeFunctions(v));
 		if (!isPlainObject(o)) return o;
-		return Object.entries(o).filter(([_, value]) => typeof value !== "function").map(([key, value]) => {
-			if (Array.isArray(value)) return { [key]: value.map((v) => removeFunctions(v)) };
-			else if (typeof value === "object") return { [key]: removeFunctions(value) };
-			else return { [key]: value };
-		}).reduce((a, b) => ({
-			...a,
-			...b
-		}), {});
+		return Object.entries(o).filter(([_, value]) => typeof value !== "function").reduce((acc, [key, value]) => {
+			acc[key] = removeFunctions(value);
+			return acc;
+		}, {});
 	}
 	return o;
 }
@@ -1215,11 +1211,101 @@ function getPolicyNamesForRule(rule, tableName) {
 	return ops.map((op, opIdx) => rule.name ? ops.length > 1 ? `${rule.name}_${op}` : rule.name : `${tableName}_${op}_${ruleHash}${ops.length > 1 ? `_${opIdx}` : ""}`);
 }
 //#endregion
+//#region ../utils/src/plurals.ts
+/**
+* Returns the singular of an English word.
+*
+* @param {string} word
+* @param {number} [amount]
+* @returns {string}
+*/
+function singular(word, amount) {
+	if (amount !== void 0 && amount !== 1) return word;
+	const singulars = {
+		"(quiz)zes$": "$1",
+		"(matr)ices$": "$1ix",
+		"(vert|ind)ices$": "$1ex",
+		"^(ox)en$": "$1",
+		"(alias)es$": "$1",
+		"(octop|vir)i$": "$1us",
+		"(cris|ax|test)es$": "$1is",
+		"(shoe)s$": "$1",
+		"(o)es$": "$1",
+		"(bus)es$": "$1",
+		"([m|l])ice$": "$1ouse",
+		"(x|ch|ss|sh)es$": "$1",
+		"(m)ovies$": "$1ovie",
+		"(s)eries$": "$1eries",
+		"([^aeiouy]|qu)ies$": "$1y",
+		"([lr])ves$": "$1f",
+		"(tive)s$": "$1",
+		"(hive)s$": "$1",
+		"(li|wi|kni)ves$": "$1fe",
+		"(shea|loa|lea|thie)ves$": "$1f",
+		"(^analy)ses$": "$1sis",
+		"((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$": "$1$2sis",
+		"([ti])a$": "$1um",
+		"(n)ews$": "$1ews",
+		"(h|bl)ouses$": "$1ouse",
+		"(corpse)s$": "$1",
+		"(us)es$": "$1",
+		s$: ""
+	};
+	const irregular = {
+		move: "moves",
+		foot: "feet",
+		goose: "geese",
+		sex: "sexes",
+		child: "children",
+		man: "men",
+		tooth: "teeth",
+		person: "people"
+	};
+	if ([
+		"sheep",
+		"fish",
+		"deer",
+		"moose",
+		"series",
+		"species",
+		"money",
+		"rice",
+		"information",
+		"equipment",
+		"bison",
+		"cod",
+		"offspring",
+		"pike",
+		"salmon",
+		"shrimp",
+		"swine",
+		"trout",
+		"aircraft",
+		"hovercraft",
+		"spacecraft",
+		"sugar",
+		"tuna",
+		"you",
+		"wood"
+	].indexOf(word.toLowerCase()) >= 0) return word;
+	for (const w in irregular) {
+		const pattern = new RegExp(`${irregular[w]}$`, "i");
+		if (pattern.test(word)) return word.replace(pattern, w);
+	}
+	for (const reg in singulars) {
+		const pattern = new RegExp(reg, "i");
+		if (pattern.test(word)) return word.replace(pattern, singulars[reg]);
+	}
+	return word;
+}
+//#endregion
 //#region ../utils/src/names.ts
 /**
 * Generates a foreign key column name from a given string, typically a collection slug or name.
-* It converts the name to snake_case, attempts to singularize it by removing a trailing 's'
-* (a common convention for collection names), and appends '_id'.
+* It singularizes the name, converts it to snake_case and appends '_id'.
+*
+* Singularization runs *before* snake-casing so that acronyms survive: `toSnakeCase`
+* splits on every capital, which turned "URLs" into "ur_ls" and then "ur_l_id".
 *
 * @param name The base name to convert to a foreign key.
 * @returns A foreign key name in the format 'singular_name_id'.
@@ -1229,8 +1315,8 @@ function getPolicyNamesForRule(rule, tableName) {
 * generateForeignKeyName("users")
 *
 * @example
-* // returns "post_id"
-* generateForeignKeyName("posts")
+* // returns "category_id"
+* generateForeignKeyName("categories")
 *
 * @example
 * // returns "product_id"
@@ -1238,8 +1324,41 @@ function getPolicyNamesForRule(rule, tableName) {
 *
 */
 function generateForeignKeyName(name) {
-	const snakeCaseName = toSnakeCase(name);
-	return `${snakeCaseName.endsWith("s") ? snakeCaseName.slice(0, -1) : snakeCaseName}_id`;
+	return `${toSnakeCase(singularizeForKey(name))}_id`;
+}
+/**
+* `singular()` handles real English plurals, but its final catch-all rule strips
+* any trailing "s", which mangles words that only look plural. Guard the two
+* cases that produce a column name nobody would recognise:
+*
+* - a double "s" ending is never a plural marker ("address", "class", "process"),
+*   so stripping it yields "addres";
+* - a name that singularizes to nothing (the literal "s") would yield "_id".
+*/
+function singularizeForKey(name) {
+	if (/ss$/i.test(name)) return name;
+	const result = singular(name);
+	return result.length > 0 ? result : name;
+}
+/**
+* What `generateForeignKeyName` returned before it learned to singularize:
+* snake-case the name, then chop one trailing "s".
+*
+* This is here to be *detected*, never to be generated. A database provisioned
+* under the old rule carries `categorie_id`, `addresse_id`, `children_id` or
+* `ur_l_id` where the current rule expects `category_id`, `address_id`,
+* `child_id` and `url_id` — and the boot-time schema ensure is additive, so it
+* would create the new column empty beside the populated old one and leave the
+* relation reading nothing. No error, no missing table: the failure is silent,
+* which is the only reason this function still exists.
+*
+* `ensureCollectionSchema` calls it to recognise that shape and say so.
+* Returns the same string as `generateForeignKeyName` for every regular plural,
+* so a caller can compare the two and act only when they differ.
+*/
+function legacyForeignKeyName(name) {
+	const snake = toSnakeCase(name);
+	return `${snake.endsWith("s") ? snake.slice(0, -1) : snake}_id`;
 }
 //#endregion
 //#region ../common/src/util/entities.ts
@@ -3731,7 +3850,7 @@ function rowToEntity(row, slug, primaryKeys = []) {
 	};
 }
 /**
-* The relation envelope `toCmsRow` writes where a relation was:
+* The relation envelope `toFlatRow` writes where a relation was:
 * `{ id, path, __type: "relation", data: { id, path, values } }`. It is the
 * admin's view-model, and the only pipeline that produces one is postgres'.
 */
@@ -4109,6 +4228,6 @@ function buildSdkData(driver) {
 	return wrapAsSdkData(buildRebaseData(driver));
 }
 //#endregion
-export { DEFAULT_ONE_OF_VALUE as A, updateDateAutoValues as C, camelCase as D, mergeDeep as E, isManyToMany as M, Vector as N, toSnakeCase as O, normalizeToEntityRelation as S, getPolicyNamesForRule as T, buildCompositeId as _, getJunctionSecurityRules as a, createRelationRef as b, policyToPostgres as c, findRelation as d, getColumnName as f, resolveCollectionRelations as g, getTableVarName as h, getJunctionCollectionConfig as i, hasForeignKeyOnTarget as j, DEFAULT_ONE_OF_TYPE as k, securityRuleToConditions as l, getTableName as m, CollectionRegistry as n, resolveJunctionSpecs as o, getEnumVarName as p, resolveStringColumnLength as r, getEffectiveSecurityRules as s, buildSdkData as t, findAnonymousGrants as u, getDeclaredPrimaryKeys as v, generateForeignKeyName as w, createRelationRefWithData as x, parseIdValues as y };
+export { DEFAULT_ONE_OF_TYPE as A, updateDateAutoValues as C, mergeDeep as D, getPolicyNamesForRule as E, hasForeignKeyOnTarget as M, isManyToMany as N, camelCase as O, Vector as P, normalizeToEntityRelation as S, legacyForeignKeyName as T, buildCompositeId as _, getJunctionSecurityRules as a, createRelationRef as b, policyToPostgres as c, findRelation as d, getColumnName as f, resolveCollectionRelations as g, getTableVarName as h, getJunctionCollectionConfig as i, DEFAULT_ONE_OF_VALUE as j, toSnakeCase as k, securityRuleToConditions as l, getTableName as m, CollectionRegistry as n, resolveJunctionSpecs as o, getEnumVarName as p, resolveStringColumnLength as r, getEffectiveSecurityRules as s, buildSdkData as t, findAnonymousGrants as u, getDeclaredPrimaryKeys as v, generateForeignKeyName as w, createRelationRefWithData as x, parseIdValues as y };
 
-//# sourceMappingURL=src-C_NHNVW2.js.map
+//# sourceMappingURL=src-BkdpiQdw.js.map