@rebasepro/server-postgres 0.27.0 → 0.28.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (100) hide show
  1. package/dist/{BranchService-B9Lu8e-P.js → BranchService-BPssiD8_.js} +37 -11
  2. package/dist/BranchService-BPssiD8_.js.map +1 -0
  3. package/dist/auth/services.d.ts +19 -7
  4. package/dist/backup/pg-tools.d.ts +14 -0
  5. package/dist/backup/retention.d.ts +14 -1
  6. package/dist/{backup-cli-BZM2Fj1I.js → backup-cli-C1wcj-rc.js} +59 -11
  7. package/dist/backup-cli-C1wcj-rc.js.map +1 -0
  8. package/dist/{boot-ddl-yukSebLA.js → boot-ddl-CIGoIGcC.js} +2 -2
  9. package/dist/{boot-ddl-yukSebLA.js.map → boot-ddl-CIGoIGcC.js.map} +1 -1
  10. package/dist/branch-argv.d.ts +20 -0
  11. package/dist/{cli-console-BtzxzzvU.js → cli-console-C0FYkICX.js} +5 -5
  12. package/dist/{cli-console-BtzxzzvU.js.map → cli-console-C0FYkICX.js.map} +1 -1
  13. package/dist/{cli-errors-BBSJqlYX.js → cli-errors-DYets7cp.js} +5 -5
  14. package/dist/{cli-errors-BBSJqlYX.js.map → cli-errors-DYets7cp.js.map} +1 -1
  15. package/dist/cli.js +43 -41
  16. package/dist/cli.js.map +1 -1
  17. package/dist/data-transformer.d.ts +11 -1
  18. package/dist/{databasePoolManager-3stMNFL-.js → databasePoolManager-BjoVvuAq.js} +2 -2
  19. package/dist/databasePoolManager-BjoVvuAq.js.map +1 -0
  20. package/dist/{deferred-index-build-DRnoMq-O.js → deferred-index-build-BcJ_oulu.js} +5 -5
  21. package/dist/{deferred-index-build-DRnoMq-O.js.map → deferred-index-build-BcJ_oulu.js.map} +1 -1
  22. package/dist/{doctor-Cs6AtizY.js → doctor-TJApVglQ.js} +6 -6
  23. package/dist/{doctor-Cs6AtizY.js.map → doctor-TJApVglQ.js.map} +1 -1
  24. package/dist/{ensure-collection-policies-H8HN1Gbd.js → ensure-collection-policies-BNwSQfVx.js} +63 -25
  25. package/dist/ensure-collection-policies-BNwSQfVx.js.map +1 -0
  26. package/dist/{ensure-collection-tables-BeF1lArf.js → ensure-collection-tables-CSbgkTBx.js} +8 -9
  27. package/dist/{ensure-collection-tables-BeF1lArf.js.map → ensure-collection-tables-CSbgkTBx.js.map} +1 -1
  28. package/dist/{ensure-tables-DDkNaPN2.js → ensure-tables-CF-8zgYA.js} +3 -3
  29. package/dist/{ensure-tables-DDkNaPN2.js.map → ensure-tables-CF-8zgYA.js.map} +1 -1
  30. package/dist/{enum-labels-kept-B6loB2U_.js → enum-labels-kept-BCgFGAbJ.js} +3 -3
  31. package/dist/{enum-labels-kept-B6loB2U_.js.map → enum-labels-kept-BCgFGAbJ.js.map} +1 -1
  32. package/dist/{generate-drizzle-schema-D_O8_iyT.js → generate-drizzle-schema-BAIp9nKT.js} +2 -2
  33. package/dist/{generate-drizzle-schema-D_O8_iyT.js.map → generate-drizzle-schema-BAIp9nKT.js.map} +1 -1
  34. package/dist/{generate-drizzle-schema-logic-D0E64iwx.js → generate-drizzle-schema-logic-CVRmZjP3.js} +2 -2
  35. package/dist/{generate-drizzle-schema-logic-D0E64iwx.js.map → generate-drizzle-schema-logic-CVRmZjP3.js.map} +1 -1
  36. package/dist/{generate-files-BpgyRwhU.js → generate-files-DutUrsSS.js} +3 -3
  37. package/dist/{generate-files-BpgyRwhU.js.map → generate-files-DutUrsSS.js.map} +1 -1
  38. package/dist/{generate-postgres-ddl-logic-CogQBrzs.js → generate-postgres-ddl-logic-0rbAqwYT.js} +22 -10
  39. package/dist/generate-postgres-ddl-logic-0rbAqwYT.js.map +1 -0
  40. package/dist/{generated-schema-diff-X9NA2Vig.js → generated-schema-diff-ChFg6UxI.js} +13 -4
  41. package/dist/{generated-schema-diff-X9NA2Vig.js.map → generated-schema-diff-ChFg6UxI.js.map} +1 -1
  42. package/dist/history/HistoryService.d.ts +5 -0
  43. package/dist/index.es.js +14 -13
  44. package/dist/index.es.js.map +1 -1
  45. package/dist/{migrate-baseline-Bfk1LGC6.js → migrate-baseline-DPawvckr.js} +54 -11
  46. package/dist/{migrate-baseline-Bfk1LGC6.js.map → migrate-baseline-DPawvckr.js.map} +1 -1
  47. package/dist/{migrate-policy-stamps-DHxwcawC.js → migrate-policy-stamps-B-8vTSIm.js} +6 -6
  48. package/dist/{migrate-policy-stamps-DHxwcawC.js.map → migrate-policy-stamps-B-8vTSIm.js.map} +1 -1
  49. package/dist/{open-rebase-DZ5JbZpg.js → open-rebase-D9n8idex.js} +1436 -200
  50. package/dist/open-rebase-D9n8idex.js.map +1 -0
  51. package/dist/{pg-error-utils-BueZEJ0S.js → pg-error-utils-BIHfsGZL.js} +2 -2
  52. package/dist/{pg-error-utils-BueZEJ0S.js.map → pg-error-utils-BIHfsGZL.js.map} +1 -1
  53. package/dist/{plan-schema-YagMlmNE.js → plan-schema-DMVh77yb.js} +28 -1
  54. package/dist/plan-schema-DMVh77yb.js.map +1 -0
  55. package/dist/{policy-drift-Dqp_yFeE.js → policy-drift-0Cp4Lc0x.js} +13 -4
  56. package/dist/policy-drift-0Cp4Lc0x.js.map +1 -0
  57. package/dist/{push-index-prebuild-hVRrfTi-.js → push-index-prebuild-DR3P4yOw.js} +4 -4
  58. package/dist/{push-index-prebuild-hVRrfTi-.js.map → push-index-prebuild-DR3P4yOw.js.map} +1 -1
  59. package/dist/{push-kept-defaults-M_ZCcXuy.js → push-kept-defaults-BSqPzp0T.js} +2 -2
  60. package/dist/{push-kept-defaults-M_ZCcXuy.js.map → push-kept-defaults-BSqPzp0T.js.map} +1 -1
  61. package/dist/{push-legacy-renames-DcoAWmGt.js → push-legacy-renames-BIxBmVLl.js} +4 -4
  62. package/dist/{push-legacy-renames-DcoAWmGt.js.map → push-legacy-renames-BIxBmVLl.js.map} +1 -1
  63. package/dist/{push-policy-plan-Bq1bcb3Y.js → push-policy-plan-BHsasXa7.js} +4 -4
  64. package/dist/{push-policy-plan-Bq1bcb3Y.js.map → push-policy-plan-BHsasXa7.js.map} +1 -1
  65. package/dist/{render-ddl-D5jeXKR-.js → render-ddl-NpPPDACz.js} +20 -3
  66. package/dist/render-ddl-NpPPDACz.js.map +1 -0
  67. package/dist/schema/doctor-cli.js +3 -3
  68. package/dist/schema/ensure-collection-policies.d.ts +6 -4
  69. package/dist/schema/generate-drizzle-schema.js +1 -1
  70. package/dist/schema/generate-postgres-ddl-logic.d.ts +16 -0
  71. package/dist/schema/generate-postgres-ddl.js +1 -1
  72. package/dist/schema/generated-schema-diff.d.ts +6 -0
  73. package/dist/schema/introspect-db.js +1 -1
  74. package/dist/schema/plan/render-ddl.d.ts +11 -0
  75. package/dist/schema/reconcile-schema.d.ts +21 -0
  76. package/dist/security/policy-drift.d.ts +9 -1
  77. package/dist/services/BranchService.d.ts +6 -0
  78. package/dist/services/RelationService.d.ts +6 -6
  79. package/dist/services/cdc/CdcListener.d.ts +12 -0
  80. package/dist/services/cdc/WalCdcListener.d.ts +92 -0
  81. package/dist/services/cdc/pgoutput.d.ts +121 -0
  82. package/dist/services/cdc/wal-cdc.d.ts +29 -0
  83. package/dist/services/collection-helpers.d.ts +14 -0
  84. package/dist/services/junction-writes.d.ts +9 -1
  85. package/dist/services/nested-path.d.ts +2 -1
  86. package/dist/services/realtimeService.d.ts +47 -2
  87. package/dist/utils/drizzle-conditions.d.ts +11 -0
  88. package/dist/{websocket-C9Fx7iSx.js → websocket-D4wrzF3b.js} +6 -5
  89. package/dist/websocket-D4wrzF3b.js.map +1 -0
  90. package/package.json +7 -7
  91. package/dist/BranchService-B9Lu8e-P.js.map +0 -1
  92. package/dist/backup-cli-BZM2Fj1I.js.map +0 -1
  93. package/dist/databasePoolManager-3stMNFL-.js.map +0 -1
  94. package/dist/ensure-collection-policies-H8HN1Gbd.js.map +0 -1
  95. package/dist/generate-postgres-ddl-logic-CogQBrzs.js.map +0 -1
  96. package/dist/open-rebase-DZ5JbZpg.js.map +0 -1
  97. package/dist/plan-schema-YagMlmNE.js.map +0 -1
  98. package/dist/policy-drift-Dqp_yFeE.js.map +0 -1
  99. package/dist/render-ddl-D5jeXKR-.js.map +0 -1
  100. package/dist/websocket-C9Fx7iSx.js.map +0 -1
@@ -1,6 +1,6 @@
1
1
  import { createRequire as __createRequire } from "module";
2
2
  __createRequire(import.meta.url);
3
- import { rt as extractCauseMessage } from "./cli-errors-BBSJqlYX.js";
3
+ import { rt as extractCauseMessage } from "./cli-errors-DYets7cp.js";
4
4
  import { DATABASE_UNAVAILABLE_MESSAGE, declaredErrorAnswer, isDatabaseUnreachable, logger } from "@rebasepro/server";
5
5
  import { fieldKeyForColumn, getTableName } from "@rebasepro/common";
6
6
  //#region src/utils/pg-error-utils.ts
@@ -399,4 +399,4 @@ function sanitizeErrorForClient(error, context, options = {}) {
399
399
  //#endregion
400
400
  export { pgErrorToFriendlyMessage as a, isRowLevelSecurityDenial as i, extractPgError as n, reachedDatabase as o, isRoleSwitchingPermissionError as r, sanitizeErrorForClient as s, classifyConnectFailure as t };
401
401
 
402
- //# sourceMappingURL=pg-error-utils-BueZEJ0S.js.map
402
+ //# sourceMappingURL=pg-error-utils-BIHfsGZL.js.map
@@ -1 +1 @@
1
- {"version":3,"file":"pg-error-utils-BueZEJ0S.js","names":[],"sources":["../src/utils/pg-error-utils.ts"],"sourcesContent":["/**\n * Shared PostgreSQL error extraction and user-friendly message formatting.\n *\n * Drizzle wraps native PG errors in a `.cause` chain. These utilities\n * unwrap that chain to get the real PostgreSQL error (identified by a\n * 5-character alphanumeric `code` such as `42P01`) and translate it into\n * a message that is safe and helpful to show to end-users.\n */\n\nimport { DATABASE_UNAVAILABLE_MESSAGE, declaredErrorAnswer, isDatabaseUnreachable, logger } from \"@rebasepro/server\";\nimport type { CollectionConfig } from \"@rebasepro/types\";\nimport { fieldKeyForColumn, getTableName } from \"@rebasepro/common\";\nimport { extractCauseMessage } from \"./error-cause\";\n\n/**\n * Shape of a deliberate client-facing error — `ApiError` from\n * `@rebasepro/server`, `RebaseApiError` from `@rebasepro/types`, or anything\n * else carrying a 4xx `statusCode`.\n *\n * Matched structurally rather than with `instanceof`: `@rebasepro/server` can\n * be loaded twice (published dist vs. workspace source), which breaks class\n * identity — `PersistService` hedges against the same thing by also accepting\n * `name === \"ApiError\"`.\n */\ninterface ClientFacingError extends Error {\n statusCode?: number;\n code?: string;\n /** See `ApiError.expected` — routine outcomes log at debug, not warn. */\n expected?: boolean;\n}\n\n/**\n * Return the error when it is a deliberate 4xx, otherwise null.\n *\n * A thrown `ApiError` is a decision the server made about the request, not a\n * database failure: its message and code are already written for the client.\n *\n * So is a `RebaseApiError` — what a collection callback throws, since a\n * collection file cannot import the server package. It spells its status\n * `status`, and reading only `statusCode` here turned an `afterRead` that\n * refused with a 403 into \"Could not load data … Check server logs\" on a\n * subscription, where REST and the socket's own requests answer the 403.\n * Recognised by the predicate those doors use, `declaredErrorAnswer`.\n */\nfunction asClientFacingError(error: unknown): Pick<ClientFacingError, \"statusCode\" | \"code\" | \"message\" | \"expected\"> | null {\n const answer = declaredErrorAnswer(error);\n if (answer) {\n if (answer.status < 400 || answer.status >= 500) return null;\n return { statusCode: answer.status, code: answer.code, message: answer.message, expected: answer.expected };\n }\n if (!(error instanceof Error)) return null;\n const e = error as ClientFacingError;\n if (typeof e.statusCode !== \"number\" || e.statusCode < 400 || e.statusCode >= 500) return null;\n return e;\n}\n\n/** Shape of PostgreSQL errors with diagnostic metadata. */\nexport interface PostgresError extends Error {\n code?: string;\n detail?: string;\n hint?: string;\n constraint?: string;\n column?: string;\n table?: string;\n dataType?: string;\n cause?: unknown;\n}\n\n/**\n * Extract the underlying PostgreSQL error from a Drizzle wrapper.\n * Drizzle wraps PG errors in a `cause` property — this function\n * recursively walks the chain until it finds an object with a PG\n * error code (5-char alphanumeric, e.g. `42P01`).\n */\nexport function extractPgError(error: unknown): PostgresError | null {\n if (!error || typeof error !== \"object\") return null;\n if (!(error instanceof Error)) {\n // Check non-Error objects for a cause chain (Drizzle sometimes wraps oddly)\n if (\"cause\" in error && (error as Record<string, unknown>).cause && typeof (error as Record<string, unknown>).cause === \"object\") {\n return extractPgError((error as Record<string, unknown>).cause);\n }\n return null;\n }\n\n // Check if the error itself has a PG error code\n if (\"code\" in error && typeof (error as PostgresError).code === \"string\" && /^[0-9A-Z]{5}$/.test((error as PostgresError).code!)) {\n return error as PostgresError;\n }\n\n // Check the cause chain (Drizzle wraps PG errors)\n if (error.cause && typeof error.cause === \"object\") {\n return extractPgError(error.cause);\n }\n\n return null;\n}\n\n/**\n * Whether the failure came back from Postgres rather than from building the\n * query — which decides whether a fallback query is worth issuing.\n *\n * Reads here run inside a transaction (that is where `SET LOCAL ROLE` binds\n * RLS). Once a statement raises, that transaction is aborted, and every later\n * statement on it returns `25P02` — \"current transaction is aborted, commands\n * ignored until end of transaction block\". So a retry after a database error\n * cannot succeed, and it replaces a precise diagnosis (\"invalid input syntax\n * for type uuid\") with a generic one. Rethrow instead.\n *\n * A query the driver could not even build — a missing reciprocal relation, say\n * — never reached Postgres, leaves the transaction usable, and is exactly what\n * the fallback paths exist for.\n */\nexport function reachedDatabase(error: unknown): boolean {\n return extractPgError(error) !== null;\n}\n\n// In its own module so the driver CLI can use it without loading the server\n// (this file imports `@rebasepro/server`).\nexport { extractCauseMessage };\n\n/**\n * Codes that mean \"this connection will never work as configured\".\n *\n * A wrong password or a database that does not exist is a settled fact about\n * the connection string, not a transient fault — retrying produces the same\n * answer forever.\n */\nconst UNRECOVERABLE_CONNECT_CODES = new Set([\n \"28P01\", // invalid_password\n \"28000\", // invalid_authorization_specification\n \"3D000\", // invalid_catalog_name — the database does not exist\n \"42501\" // insufficient_privilege\n]);\n\nexport interface ConnectFailure {\n /** True when retrying cannot help: the connection string itself is wrong. */\n fatal: boolean;\n /** The deepest message available — the Postgres one where there is one. */\n reason: string;\n /** The `SQLSTATE`, when the failure came from Postgres rather than the socket. */\n code?: string;\n}\n\n/**\n * Describe a failed connection attempt in terms a developer can act on.\n *\n * The error a caller catches is Drizzle's wrapper: its message is\n * `Failed query: SELECT 1` and its stack runs through drizzle internals, while\n * the sentence that says what is actually wrong — \"password authentication\n * failed for user …\", \"database … does not exist\" — sits in `.cause`. Logging\n * the wrapper, as the bootstrapper used to, tells a developer with a typo in\n * their `DATABASE_URL` nothing at all.\n */\nexport function classifyConnectFailure(error: unknown): ConnectFailure {\n const pgError = extractPgError(error);\n const reason =\n pgError?.message ??\n extractCauseMessage(error) ??\n (error instanceof Error ? error.message : String(error));\n return {\n fatal: Boolean(pgError?.code && UNRECOVERABLE_CONNECT_CODES.has(pgError.code)),\n reason,\n code: pgError?.code\n };\n}\n\n/**\n * Detect whether an error is specifically a role-switching permission failure\n * (e.g. \"permission denied to set role\" or \"must be member of role\"),\n * as opposed to a table-level permission denial.\n *\n * This is used by the backend driver to auto-disable role switching when the\n * connection user lacks SET ROLE privileges, rather than surfacing a confusing\n * error to the Studio SQL Editor user.\n */\nexport function isRoleSwitchingPermissionError(error: unknown): boolean {\n const pgError = extractPgError(error);\n if (!pgError || pgError.code !== \"42501\") return false;\n const msg = pgError.message.toLowerCase();\n return msg.includes(\"set role\") || msg.includes(\"member of role\");\n}\n\n/**\n * Was this `42501` the *caller* being refused by a policy, rather than the\n * server lacking a privilege?\n *\n * Both arrive as `insufficient_privilege`, and they are opposite kinds of\n * problem. A row-level-security refusal is a working access-control system\n * doing its job: the caller asked for something their policies do not permit,\n * which is a 403 and nobody's bug. A missing `GRANT` is the deployment being\n * wrong — the connection role cannot touch the table at all, no policy is\n * involved, and nothing the caller changes about the request will help.\n *\n * Postgres distinguishes them in the message, so this does too:\n *\n * new row violates row-level security policy for table \"notes\" → the caller\n * permission denied for table notes → the server\n *\n * Only writes reach this. A read that RLS excludes is not an error — the rows\n * are filtered and the caller gets an empty page — so the erroring case is\n * specifically an `INSERT`/`UPDATE` whose row fails a policy's `WITH CHECK`.\n *\n * Matched on the message because that is the only thing carrying the\n * distinction; the SQLSTATE is identical either way. Narrow by design: anything\n * not naming row-level security stays the server's problem, since reporting a\n * genuine privilege misconfiguration as \"forbidden\" would send an operator\n * hunting for a policy bug that does not exist.\n */\nexport function isRowLevelSecurityDenial(error: unknown): boolean {\n const pgError = extractPgError(error);\n if (!pgError || pgError.code !== \"42501\") return false;\n return pgError.message.toLowerCase().includes(\"row-level security policy\");\n}\n\n/**\n * One constraint the database refused, named in the caller's vocabulary.\n *\n * `field` is the **wire** name, derived from the physical column: `author_id`\n * on the table is `authorId` on the row and in the request body, and telling a\n * caller their `author_id` is missing sends them looking for a key their client\n * has never seen. `code` is the SQLSTATE, which is stable, documented by\n * Postgres and the same in every environment — unlike the message, which is\n * deliberately thinner in production.\n *\n * Deliberately no `value`. The column name is safe to publish: it is already in\n * the OpenAPI, the generated SDK and the caller's own request. The *value* is\n * not — `23505`'s detail reads `Key (email)=(a@b.c) already exists.`, which\n * answers \"is this person registered?\" for any address on a table whose rows\n * RLS is otherwise hiding completely.\n */\nexport interface PgFieldViolation {\n field: string;\n code: string;\n}\n\n/**\n * The physical column names a Postgres error is about.\n *\n * Postgres puts one in `column` for `23502` and nowhere else, so the rest are\n * read out of the two places that do carry them:\n *\n * - `detail` — `Key (author_id)=(9) is not present in table \"authors\".` and\n * `Key (email, tenant_id)=(…) already exists.` Only the parenthesised column\n * list is read; the values after `=` are never touched.\n * - `constraint` — `users_email_key`, `posts_author_id_fkey`. The table prefix\n * and the constraint suffix are stripped, leaving the columns joined by `_`,\n * which is ambiguous for multi-column constraints and is therefore only used\n * when `detail` gave nothing.\n *\n * `22P02` carries neither, because an invalid literal fails during parse rather\n * than against a constraint. Its message names the *type*, and an enum type is\n * generated as `<table>_<column>` — which is the one case worth decoding,\n * because a value outside an enum's labels is the most common 22P02 anyone\n * hits and the least legible one.\n */\nfunction offendingColumns(pgError: PostgresError, collection?: CollectionConfig): string[] {\n if (pgError.column) return [pgError.column];\n\n const detail = pgError.detail;\n if (detail) {\n const keyed = /Key \\(([^)]+)\\)=/.exec(detail);\n if (keyed) {\n return keyed[1].split(\",\").map(part => part.trim().replace(/^\"|\"$/g, \"\")).filter(Boolean);\n }\n }\n\n if (pgError.code === \"22P02\") {\n // `invalid input value for enum posts_status: \"archived\"`\n const enumType = /invalid input value for enum ([^:\\s]+)/i.exec(pgError.message ?? \"\");\n if (enumType && collection) {\n const typeName = enumType[1].replace(/^.*\\./, \"\").replace(/\"/g, \"\");\n const table = getTableName(collection);\n if (typeName.startsWith(`${table}_`)) return [typeName.slice(table.length + 1)];\n }\n return [];\n }\n\n const constraint = pgError.constraint;\n if (constraint && collection) {\n const table = getTableName(collection);\n const stripped = constraint\n .replace(new RegExp(`^${table}_`), \"\")\n .replace(/_(pkey|key|fkey|unique|check|excl|idx)$/, \"\");\n // Only when it names something the collection actually has: a\n // hand-written constraint name is not a column list, and guessing at one\n // would put a field in the response that does not exist.\n if (stripped && stripped !== constraint) {\n const columns = new Set<string>();\n for (const [key, prop] of Object.entries(collection.properties ?? {})) {\n columns.add((prop as { columnName?: string })?.columnName ?? key);\n }\n if (columns.has(stripped)) return [stripped];\n const wire = fieldKeyForColumn(collection, stripped);\n if (collection.properties && wire in collection.properties) return [stripped];\n }\n }\n\n return [];\n}\n\n/**\n * The fields a Postgres error is about, for `details.violations`.\n *\n * Only the four SQLSTATEs that describe *the caller's data*: a missing value, a\n * duplicate, a bad literal, a foreign key pointing at nothing. Everything else\n * — a dropped connection, a missing table, a privilege problem — is the\n * deployment's, and naming a field for it would send the reader to the wrong\n * place.\n *\n * Empty when the collection is unknown or the column cannot be recovered. An\n * empty list is the honest answer; inventing a field is worse than saying\n * nothing, because a form will mark the wrong input red.\n */\nexport function pgFieldViolations(\n pgError: PostgresError,\n collection?: CollectionConfig\n): PgFieldViolation[] {\n const code = pgError.code;\n if (code !== \"23502\" && code !== \"23505\" && code !== \"22P02\" && code !== \"23503\") return [];\n // Without the collection there is no mapping, only a guess. `toWireKey`\n // would get the default case right and silently invent a field for any\n // property carrying an explicit `columnName` — and a form pointed at an\n // input that does not exist is worse off than one shown the raw column.\n if (!collection) return [];\n const columns = offendingColumns(pgError, collection);\n if (columns.length === 0) return [];\n return columns.map(column => ({\n field: fieldKeyForColumn(collection, column),\n code\n }));\n}\n\n/**\n * What a missing table or column most often means: the database is behind the\n * collections. Both ways of catching it up, because \"run migrations\" alone\n * sent a project on the managed development database — which nobody\n * migrates — the wrong way.\n */\nconst SCHEMA_BEHIND =\n \"Check that the database is up to date with the collections: `rebase db push` in development, \" +\n \"or `rebase db migrate` where migrations are used.\";\n\n/**\n * Translate a raw PostgreSQL error into a user-friendly message.\n *\n * @param pgError - The extracted PostgreSQL error (from {@link extractPgError})\n * @param context - A human-readable context string (e.g. collection slug or path)\n * @returns An object with a `message` safe for the client and the PG `code`.\n */\nexport function pgErrorToFriendlyMessage(\n pgError: PostgresError,\n context: string,\n options: { verbose?: boolean; collection?: CollectionConfig } = {}\n): { message: string; code: string; violations: PgFieldViolation[] } {\n // Postgres's own `DETAIL` and `HINT`, and the raw driver message, are what\n // make these errors useful while you are building — and what makes them an\n // oracle once the server is answering strangers.\n //\n // The sharp one is `23505`: its detail reads `Key (email)=(a@b.c) already\n // exists.`, which answers \"is this person registered?\" for any address, on\n // a table whose rows RLS is otherwise hiding completely. The rest leak\n // physical column and constraint names, which are the map for the next\n // question. So in production the shape of the failure is served — what\n // rule was broken, and where — and the values are not.\n //\n // The full text is not lost: the caller logs the original error. This\n // decides what crosses the wire, not what is recorded.\n const verbose = options.verbose ?? process.env.NODE_ENV !== \"production\";\n\n const detail = verbose ? (pgError.detail as string | undefined) : undefined;\n const hint = verbose ? (pgError.hint as string | undefined) : undefined;\n const constraint = pgError.constraint as string | undefined;\n const column = pgError.column as string | undefined;\n const table = pgError.table as string | undefined;\n const dataType = verbose ? (pgError.dataType as string | undefined) : undefined;\n const rawMessage = pgError.message || \"Unknown database error\";\n const pgMessage = verbose ? rawMessage : \"\";\n const code = pgError.code || \"UNKNOWN\";\n\n // Which *field* the caller has to fix, derived from the column. Safe in\n // production — a column name is already published in the OpenAPI and the\n // generated SDK — where the value that broke the rule is not, and is never\n // included. See `pgFieldViolations`.\n const violations = pgFieldViolations(pgError, options.collection);\n\n const suffix = hint ? ` Hint: ${hint}` : \"\";\n const tableRef = table ?? context;\n\n /** `\": <postgres said>\"`, or nothing when the details are withheld. */\n const said = pgMessage ? `: ${pgMessage}` : \"\";\n\n switch (pgError.code) {\n case \"23503\": // foreign_key_violation\n return {\n message: detail\n ? `Foreign key constraint violated: ${detail}${suffix}`\n : `Cannot complete operation: a foreign key constraint${constraint ? ` (${constraint})` : \"\"} was violated in \"${context}\".${suffix}`,\n code,\n violations\n };\n case \"23001\": // restrict_violation\n // A row other rows still point at, under `ON DELETE RESTRICT` — the\n // default for a required link. `table` is the *referencing* table,\n // which is the one the caller has to clear or reassign first.\n return {\n message: `Cannot complete operation: rows in \"${table ?? \"another table\"}\" still reference this row in ` +\n `\"${context}\", and their foreign key${constraint ? ` (${constraint})` : \"\"} does not allow it to be ` +\n `deleted or its key changed. Delete or reassign those rows first.${detail ? ` ${detail}` : \"\"}${suffix}`,\n code,\n violations\n };\n case \"23505\": // unique_violation\n return {\n message: detail\n ? `Duplicate value: ${detail}${suffix}`\n : `Cannot complete operation: a unique constraint${constraint ? ` (${constraint})` : \"\"} was violated in \"${context}\".${suffix}`,\n code,\n violations\n };\n case \"23502\": {\n // not_null_violation. The message names the *field* when the\n // collection is known, because that is the key the caller sent and\n // the only one they can act on: told `author_id` is missing, they go\n // looking for a key their generated client has never mentioned.\n const named = violations[0]?.field ?? column ?? \"unknown\";\n return {\n message: `Missing required field: \"${named}\" in \"${tableRef}\" cannot be empty.${suffix}`,\n code,\n violations\n };\n }\n case \"23514\": // check_violation\n return {\n message: `Validation failed: a check constraint${constraint ? ` (${constraint})` : \"\"} was violated in \"${context}\".${suffix}`,\n code,\n violations\n };\n case \"22P02\": // invalid_text_representation (e.g. invalid UUID, wrong enum value)\n return {\n message: `Invalid data format in \"${context}\"${said}.${suffix}`,\n code,\n violations\n };\n case \"22001\": // string_data_right_truncation (value too long)\n return {\n message: `Value too long for column \"${column ?? \"unknown\"}\" in \"${tableRef}\"${said}.${suffix}`,\n code,\n violations\n };\n case \"22003\": // numeric_value_out_of_range\n return {\n message: `Numeric value out of range for column \"${column ?? \"unknown\"}\" in \"${tableRef}\"${said}.${suffix}`,\n code,\n violations\n };\n case \"42703\": // undefined_column\n return {\n message: `Unknown column in \"${tableRef}\"${said}. ${SCHEMA_BEHIND}${suffix}`,\n code,\n violations\n };\n case \"42P01\": // undefined_table\n return {\n message: `Table not found for \"${context}\"${said}. ${SCHEMA_BEHIND}${suffix}`,\n code,\n violations\n };\n case \"42501\": // insufficient_privilege\n // Two unrelated failures share this SQLSTATE, and the old message\n // named both causes because it could not tell them apart — which\n // meant it was half wrong whichever one had happened, and sent the\n // reader to check the other. Postgres says which in its own message.\n return rawMessage.toLowerCase().includes(\"row-level security policy\")\n ? {\n // The caller. Their policies do not permit this row; the\n // deployment is working exactly as configured.\n message: `Not permitted to write this row in \"${tableRef}\": it does not satisfy the row-level security policy.${suffix}`,\n code,\n violations\n }\n : {\n // The deployment. No policy is involved — the connecting\n // role cannot touch the table at all.\n message: `Permission denied on \"${tableRef}\": the database role this server connects as lacks privileges on it.${suffix}`,\n code,\n violations\n };\n case \"28000\": // invalid_authorization_specification\n return {\n message: `Authorization failed for \"${context}\". Check your database credentials.${suffix}`,\n code,\n violations\n };\n default: {\n // Unhandled PG code — still surface the actual database message\n const parts = [`Database error in \"${context}\" [${code}]${said}`];\n if (detail) parts.push(`Detail: ${detail}`);\n if (column) parts.push(`Column: ${column}`);\n if (dataType) parts.push(`Data type: ${dataType}`);\n if (constraint) parts.push(`Constraint: ${constraint}`);\n if (hint) parts.push(`Hint: ${hint}`);\n return { message: parts.join(\". \"), code, violations };\n }\n }\n}\n\n/**\n * Sanitize any error into a message safe and helpful for the client.\n *\n * A deliberate 4xx (`ApiError`) passes through untouched — the server already\n * decided what the client should read. Otherwise the PG error is extracted\n * from the Drizzle cause chain, falling back to a generic message that\n * doesn't leak SQL.\n *\n * @param error - The raw caught error\n * @param context - A human-readable context string (e.g. collection path)\n * @returns An object with `message` (user-friendly) and optional `code`\n * (the `ApiError` code, or the PG SQLSTATE).\n */\nexport function sanitizeErrorForClient(\n error: unknown,\n context: string,\n options: { collection?: CollectionConfig } = {}\n): { message: string; code?: string; violations?: PgFieldViolation[] } {\n // ── A deliberate 4xx is not a database failure ──────────────────\n // Its message and code are written for the client; replacing them with\n // \"Check server logs\" would discard the only diagnosis the caller gets\n // (e.g. the offending filter field and the collection's valid ones).\n // Log level follows the same convention as the HTTP error handler in\n // @rebasepro/server: routine outcomes at debug, everything else at warn.\n const clientError = asClientFacingError(error);\n if (clientError) {\n const line = `[API ${clientError.statusCode} ${clientError.code ?? \"BAD_REQUEST\"}] in \"${context}\": ${clientError.message}`;\n if (clientError.expected) {\n logger.debug(line);\n } else {\n logger.warn(`⚠️ ${line}`);\n }\n return { message: clientError.message, ...(clientError.code && { code: clientError.code }) };\n }\n\n // ── The database unreachable: the answer every door gives then ──\n // Ahead of the SQLSTATE arm, because `57P01` is a SQLSTATE that says the\n // connection is gone rather than that the statement was wrong.\n if (isDatabaseUnreachable(error)) {\n logger.warn(`[DB] The database is unreachable; \"${context}\" could not be read`);\n return { message: DATABASE_UNAVAILABLE_MESSAGE, code: \"DATABASE_UNAVAILABLE\" };\n }\n\n // ── Always log the full, unsanitized error server-side ──────────\n const pgError = extractPgError(error);\n\n if (pgError) {\n logger.error(`[PG ${pgError.code}] Error in \"${context}\"`, {\n code: pgError.code,\n message: pgError.message,\n detail: pgError.detail,\n hint: pgError.hint,\n column: pgError.column,\n table: pgError.table,\n constraint: pgError.constraint,\n dataType: pgError.dataType\n // The outer Drizzle wrapper message used to be logged here \"for\n // full context\": it is `Failed query: <sql>\\nparams: <values>`, so\n // it published the statement and every bound value (an email, a\n // password hash) on every realtime data failure. The SQLSTATE,\n // detail, table, column and constraint above are the diagnostic\n // value; the wrapper added only the leak. `logger` strips the\n // wrapper as well, but the field itself carried nothing else.\n });\n const { message, code, violations } = pgErrorToFriendlyMessage(pgError, context, { collection: options.collection });\n return { message, code, ...(violations.length > 0 && { violations }) };\n }\n\n // No PG error found — log the raw error as-is\n logger.error(`Database error in \"${context}\" (no PG error extracted)`, {\n error: error instanceof Error ? error.message : String(error),\n stack: error instanceof Error ? error.stack : undefined,\n cause: error instanceof Error && error.cause\n ? (error.cause instanceof Error ? error.cause.message : String(error.cause))\n : undefined\n });\n\n // Try to get the deepest cause message\n const causeMessage = extractCauseMessage(error);\n if (causeMessage) {\n return { message: `Database error in \"${context}\": ${causeMessage}` };\n }\n\n // Last resort — generic message, never leak raw SQL\n return { message: `Could not load data for \"${context}\". Check server logs for details.` };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,SAAS,oBAAoB,OAAgG;CACzH,MAAM,SAAS,oBAAoB,KAAK;CACxC,IAAI,QAAQ;EACR,IAAI,OAAO,SAAS,OAAO,OAAO,UAAU,KAAK,OAAO;EACxD,OAAO;GAAE,YAAY,OAAO;GAAQ,MAAM,OAAO;GAAM,SAAS,OAAO;GAAS,UAAU,OAAO;EAAS;CAC9G;CACA,IAAI,EAAE,iBAAiB,QAAQ,OAAO;CACtC,MAAM,IAAI;CACV,IAAI,OAAO,EAAE,eAAe,YAAY,EAAE,aAAa,OAAO,EAAE,cAAc,KAAK,OAAO;CAC1F,OAAO;AACX;;;;;;;AAoBA,SAAgB,eAAe,OAAsC;CACjE,IAAI,CAAC,SAAS,OAAO,UAAU,UAAU,OAAO;CAChD,IAAI,EAAE,iBAAiB,QAAQ;EAE3B,IAAI,WAAW,SAAU,MAAkC,SAAS,OAAQ,MAAkC,UAAU,UACpH,OAAO,eAAgB,MAAkC,KAAK;EAElE,OAAO;CACX;CAGA,IAAI,UAAU,SAAS,OAAQ,MAAwB,SAAS,YAAY,gBAAgB,KAAM,MAAwB,IAAK,GAC3H,OAAO;CAIX,IAAI,MAAM,SAAS,OAAO,MAAM,UAAU,UACtC,OAAO,eAAe,MAAM,KAAK;CAGrC,OAAO;AACX;;;;;;;;;;;;;;;;AAiBA,SAAgB,gBAAgB,OAAyB;CACrD,OAAO,eAAe,KAAK,MAAM;AACrC;;;;;;;;AAaA,IAAM,8CAA8B,IAAI,IAAI;CACxC;CACA;CACA;CACA;AACJ,CAAC;;;;;;;;;;;AAqBD,SAAgB,uBAAuB,OAAgC;CACnE,MAAM,UAAU,eAAe,KAAK;CACpC,MAAM,SACF,SAAS,WACT,oBAAoB,KAAK,MACxB,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;CAC1D,OAAO;EACH,OAAO,QAAQ,SAAS,QAAQ,4BAA4B,IAAI,QAAQ,IAAI,CAAC;EAC7E;EACA,MAAM,SAAS;CACnB;AACJ;;;;;;;;;;AAWA,SAAgB,+BAA+B,OAAyB;CACpE,MAAM,UAAU,eAAe,KAAK;CACpC,IAAI,CAAC,WAAW,QAAQ,SAAS,SAAS,OAAO;CACjD,MAAM,MAAM,QAAQ,QAAQ,YAAY;CACxC,OAAO,IAAI,SAAS,UAAU,KAAK,IAAI,SAAS,gBAAgB;AACpE;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,yBAAyB,OAAyB;CAC9D,MAAM,UAAU,eAAe,KAAK;CACpC,IAAI,CAAC,WAAW,QAAQ,SAAS,SAAS,OAAO;CACjD,OAAO,QAAQ,QAAQ,YAAY,CAAC,CAAC,SAAS,2BAA2B;AAC7E;;;;;;;;;;;;;;;;;;;;;AA2CA,SAAS,iBAAiB,SAAwB,YAAyC;CACvF,IAAI,QAAQ,QAAQ,OAAO,CAAC,QAAQ,MAAM;CAE1C,MAAM,SAAS,QAAQ;CACvB,IAAI,QAAQ;EACR,MAAM,QAAQ,mBAAmB,KAAK,MAAM;EAC5C,IAAI,OACA,OAAO,MAAM,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,KAAI,SAAQ,KAAK,KAAK,CAAC,CAAC,QAAQ,UAAU,EAAE,CAAC,CAAC,CAAC,OAAO,OAAO;CAEhG;CAEA,IAAI,QAAQ,SAAS,SAAS;EAE1B,MAAM,WAAW,0CAA0C,KAAK,QAAQ,WAAW,EAAE;EACrF,IAAI,YAAY,YAAY;GACxB,MAAM,WAAW,SAAS,EAAE,CAAC,QAAQ,SAAS,EAAE,CAAC,CAAC,QAAQ,MAAM,EAAE;GAClE,MAAM,QAAQ,aAAa,UAAU;GACrC,IAAI,SAAS,WAAW,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,SAAS,MAAM,MAAM,SAAS,CAAC,CAAC;EAClF;EACA,OAAO,CAAC;CACZ;CAEA,MAAM,aAAa,QAAQ;CAC3B,IAAI,cAAc,YAAY;EAC1B,MAAM,QAAQ,aAAa,UAAU;EACrC,MAAM,WAAW,WACZ,QAAQ,IAAI,OAAO,IAAI,MAAM,EAAE,GAAG,EAAE,CAAC,CACrC,QAAQ,2CAA2C,EAAE;EAI1D,IAAI,YAAY,aAAa,YAAY;GACrC,MAAM,0BAAU,IAAI,IAAY;GAChC,KAAK,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,WAAW,cAAc,CAAC,CAAC,GAChE,QAAQ,IAAK,MAAkC,cAAc,GAAG;GAEpE,IAAI,QAAQ,IAAI,QAAQ,GAAG,OAAO,CAAC,QAAQ;GAC3C,MAAM,OAAO,kBAAkB,YAAY,QAAQ;GACnD,IAAI,WAAW,cAAc,QAAQ,WAAW,YAAY,OAAO,CAAC,QAAQ;EAChF;CACJ;CAEA,OAAO,CAAC;AACZ;;;;;;;;;;;;;;AAeA,SAAgB,kBACZ,SACA,YACkB;CAClB,MAAM,OAAO,QAAQ;CACrB,IAAI,SAAS,WAAW,SAAS,WAAW,SAAS,WAAW,SAAS,SAAS,OAAO,CAAC;CAK1F,IAAI,CAAC,YAAY,OAAO,CAAC;CACzB,MAAM,UAAU,iBAAiB,SAAS,UAAU;CACpD,IAAI,QAAQ,WAAW,GAAG,OAAO,CAAC;CAClC,OAAO,QAAQ,KAAI,YAAW;EAC1B,OAAO,kBAAkB,YAAY,MAAM;EAC3C;CACJ,EAAE;AACN;;;;;;;AAQA,IAAM,gBACF;;;;;;;;AAUJ,SAAgB,yBACZ,SACA,SACA,UAAgE,CAAC,GACA;CAcjE,MAAM,UAAU,QAAQ,WAAA,QAAA,IAAA,aAAoC;CAE5D,MAAM,SAAS,UAAW,QAAQ,SAAgC,KAAA;CAClE,MAAM,OAAO,UAAW,QAAQ,OAA8B,KAAA;CAC9D,MAAM,aAAa,QAAQ;CAC3B,MAAM,SAAS,QAAQ;CACvB,MAAM,QAAQ,QAAQ;CACtB,MAAM,WAAW,UAAW,QAAQ,WAAkC,KAAA;CACtE,MAAM,aAAa,QAAQ,WAAW;CACtC,MAAM,YAAY,UAAU,aAAa;CACzC,MAAM,OAAO,QAAQ,QAAQ;CAM7B,MAAM,aAAa,kBAAkB,SAAS,QAAQ,UAAU;CAEhE,MAAM,SAAS,OAAO,UAAU,SAAS;CACzC,MAAM,WAAW,SAAS;;CAG1B,MAAM,OAAO,YAAY,KAAK,cAAc;CAE5C,QAAQ,QAAQ,MAAhB;EACI,KAAK,SACD,OAAO;GACH,SAAS,SACH,oCAAoC,SAAS,WAC7C,sDAAsD,aAAa,KAAK,WAAW,KAAK,GAAG,oBAAoB,QAAQ,IAAI;GACjI;GACA;EACJ;EACJ,KAAK,SAID,OAAO;GACH,SAAS,uCAAuC,SAAS,gBAAgB,iCACjE,QAAQ,0BAA0B,aAAa,KAAK,WAAW,KAAK,GAAG,2FACR,SAAS,IAAI,WAAW,KAAK;GACpG;GACA;EACJ;EACJ,KAAK,SACD,OAAO;GACH,SAAS,SACH,oBAAoB,SAAS,WAC7B,iDAAiD,aAAa,KAAK,WAAW,KAAK,GAAG,oBAAoB,QAAQ,IAAI;GAC5H;GACA;EACJ;EACJ,KAAK,SAMD,OAAO;GACH,SAAS,4BAFC,WAAW,EAAE,EAAE,SAAS,UAAU,UAED,QAAQ,SAAS,oBAAoB;GAChF;GACA;EACJ;EAEJ,KAAK,SACD,OAAO;GACH,SAAS,wCAAwC,aAAa,KAAK,WAAW,KAAK,GAAG,oBAAoB,QAAQ,IAAI;GACtH;GACA;EACJ;EACJ,KAAK,SACD,OAAO;GACH,SAAS,2BAA2B,QAAQ,GAAG,KAAK,GAAG;GACvD;GACA;EACJ;EACJ,KAAK,SACD,OAAO;GACH,SAAS,8BAA8B,UAAU,UAAU,QAAQ,SAAS,GAAG,KAAK,GAAG;GACvF;GACA;EACJ;EACJ,KAAK,SACD,OAAO;GACH,SAAS,0CAA0C,UAAU,UAAU,QAAQ,SAAS,GAAG,KAAK,GAAG;GACnG;GACA;EACJ;EACJ,KAAK,SACD,OAAO;GACH,SAAS,sBAAsB,SAAS,GAAG,KAAK,IAAI,gBAAgB;GACpE;GACA;EACJ;EACJ,KAAK,SACD,OAAO;GACH,SAAS,wBAAwB,QAAQ,GAAG,KAAK,IAAI,gBAAgB;GACrE;GACA;EACJ;EACJ,KAAK,SAKD,OAAO,WAAW,YAAY,CAAC,CAAC,SAAS,2BAA2B,IAC9D;GAGE,SAAS,uCAAuC,SAAS,uDAAuD;GAChH;GACA;EACJ,IACE;GAGE,SAAS,yBAAyB,SAAS,sEAAsE;GACjH;GACA;EACJ;EACR,KAAK,SACD,OAAO;GACH,SAAS,6BAA6B,QAAQ,qCAAqC;GACnF;GACA;EACJ;EACJ,SAAS;GAEL,MAAM,QAAQ,CAAC,sBAAsB,QAAQ,KAAK,KAAK,GAAG,MAAM;GAChE,IAAI,QAAQ,MAAM,KAAK,WAAW,QAAQ;GAC1C,IAAI,QAAQ,MAAM,KAAK,WAAW,QAAQ;GAC1C,IAAI,UAAU,MAAM,KAAK,cAAc,UAAU;GACjD,IAAI,YAAY,MAAM,KAAK,eAAe,YAAY;GACtD,IAAI,MAAM,MAAM,KAAK,SAAS,MAAM;GACpC,OAAO;IAAE,SAAS,MAAM,KAAK,IAAI;IAAG;IAAM;GAAW;EACzD;CACJ;AACJ;;;;;;;;;;;;;;AAeA,SAAgB,uBACZ,OACA,SACA,UAA6C,CAAC,GACqB;CAOnE,MAAM,cAAc,oBAAoB,KAAK;CAC7C,IAAI,aAAa;EACb,MAAM,OAAO,QAAQ,YAAY,WAAW,GAAG,YAAY,QAAQ,cAAc,QAAQ,QAAQ,KAAK,YAAY;EAClH,IAAI,YAAY,UACZ,OAAO,MAAM,IAAI;OAEjB,OAAO,KAAK,MAAM,MAAM;EAE5B,OAAO;GAAE,SAAS,YAAY;GAAS,GAAI,YAAY,QAAQ,EAAE,MAAM,YAAY,KAAK;EAAG;CAC/F;CAKA,IAAI,sBAAsB,KAAK,GAAG;EAC9B,OAAO,KAAK,sCAAsC,QAAQ,oBAAoB;EAC9E,OAAO;GAAE,SAAS;GAA8B,MAAM;EAAuB;CACjF;CAGA,MAAM,UAAU,eAAe,KAAK;CAEpC,IAAI,SAAS;EACT,OAAO,MAAM,OAAO,QAAQ,KAAK,cAAc,QAAQ,IAAI;GACvD,MAAM,QAAQ;GACd,SAAS,QAAQ;GACjB,QAAQ,QAAQ;GAChB,MAAM,QAAQ;GACd,QAAQ,QAAQ;GAChB,OAAO,QAAQ;GACf,YAAY,QAAQ;GACpB,UAAU,QAAQ;EAQtB,CAAC;EACD,MAAM,EAAE,SAAS,MAAM,eAAe,yBAAyB,SAAS,SAAS,EAAE,YAAY,QAAQ,WAAW,CAAC;EACnH,OAAO;GAAE;GAAS;GAAM,GAAI,WAAW,SAAS,KAAK,EAAE,WAAW;EAAG;CACzE;CAGA,OAAO,MAAM,sBAAsB,QAAQ,4BAA4B;EACnE,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;EAC5D,OAAO,iBAAiB,QAAQ,MAAM,QAAQ,KAAA;EAC9C,OAAO,iBAAiB,SAAS,MAAM,QAChC,MAAM,iBAAiB,QAAQ,MAAM,MAAM,UAAU,OAAO,MAAM,KAAK,IACxE,KAAA;CACV,CAAC;CAGD,MAAM,eAAe,oBAAoB,KAAK;CAC9C,IAAI,cACA,OAAO,EAAE,SAAS,sBAAsB,QAAQ,KAAK,eAAe;CAIxE,OAAO,EAAE,SAAS,4BAA4B,QAAQ,mCAAmC;AAC7F"}
1
+ {"version":3,"file":"pg-error-utils-BIHfsGZL.js","names":[],"sources":["../src/utils/pg-error-utils.ts"],"sourcesContent":["/**\n * Shared PostgreSQL error extraction and user-friendly message formatting.\n *\n * Drizzle wraps native PG errors in a `.cause` chain. These utilities\n * unwrap that chain to get the real PostgreSQL error (identified by a\n * 5-character alphanumeric `code` such as `42P01`) and translate it into\n * a message that is safe and helpful to show to end-users.\n */\n\nimport { DATABASE_UNAVAILABLE_MESSAGE, declaredErrorAnswer, isDatabaseUnreachable, logger } from \"@rebasepro/server\";\nimport type { CollectionConfig } from \"@rebasepro/types\";\nimport { fieldKeyForColumn, getTableName } from \"@rebasepro/common\";\nimport { extractCauseMessage } from \"./error-cause\";\n\n/**\n * Shape of a deliberate client-facing error — `ApiError` from\n * `@rebasepro/server`, `RebaseApiError` from `@rebasepro/types`, or anything\n * else carrying a 4xx `statusCode`.\n *\n * Matched structurally rather than with `instanceof`: `@rebasepro/server` can\n * be loaded twice (published dist vs. workspace source), which breaks class\n * identity — `PersistService` hedges against the same thing by also accepting\n * `name === \"ApiError\"`.\n */\ninterface ClientFacingError extends Error {\n statusCode?: number;\n code?: string;\n /** See `ApiError.expected` — routine outcomes log at debug, not warn. */\n expected?: boolean;\n}\n\n/**\n * Return the error when it is a deliberate 4xx, otherwise null.\n *\n * A thrown `ApiError` is a decision the server made about the request, not a\n * database failure: its message and code are already written for the client.\n *\n * So is a `RebaseApiError` — what a collection callback throws, since a\n * collection file cannot import the server package. It spells its status\n * `status`, and reading only `statusCode` here turned an `afterRead` that\n * refused with a 403 into \"Could not load data … Check server logs\" on a\n * subscription, where REST and the socket's own requests answer the 403.\n * Recognised by the predicate those doors use, `declaredErrorAnswer`.\n */\nfunction asClientFacingError(error: unknown): Pick<ClientFacingError, \"statusCode\" | \"code\" | \"message\" | \"expected\"> | null {\n const answer = declaredErrorAnswer(error);\n if (answer) {\n if (answer.status < 400 || answer.status >= 500) return null;\n return { statusCode: answer.status, code: answer.code, message: answer.message, expected: answer.expected };\n }\n if (!(error instanceof Error)) return null;\n const e = error as ClientFacingError;\n if (typeof e.statusCode !== \"number\" || e.statusCode < 400 || e.statusCode >= 500) return null;\n return e;\n}\n\n/** Shape of PostgreSQL errors with diagnostic metadata. */\nexport interface PostgresError extends Error {\n code?: string;\n detail?: string;\n hint?: string;\n constraint?: string;\n column?: string;\n table?: string;\n dataType?: string;\n cause?: unknown;\n}\n\n/**\n * Extract the underlying PostgreSQL error from a Drizzle wrapper.\n * Drizzle wraps PG errors in a `cause` property — this function\n * recursively walks the chain until it finds an object with a PG\n * error code (5-char alphanumeric, e.g. `42P01`).\n */\nexport function extractPgError(error: unknown): PostgresError | null {\n if (!error || typeof error !== \"object\") return null;\n if (!(error instanceof Error)) {\n // Check non-Error objects for a cause chain (Drizzle sometimes wraps oddly)\n if (\"cause\" in error && (error as Record<string, unknown>).cause && typeof (error as Record<string, unknown>).cause === \"object\") {\n return extractPgError((error as Record<string, unknown>).cause);\n }\n return null;\n }\n\n // Check if the error itself has a PG error code\n if (\"code\" in error && typeof (error as PostgresError).code === \"string\" && /^[0-9A-Z]{5}$/.test((error as PostgresError).code!)) {\n return error as PostgresError;\n }\n\n // Check the cause chain (Drizzle wraps PG errors)\n if (error.cause && typeof error.cause === \"object\") {\n return extractPgError(error.cause);\n }\n\n return null;\n}\n\n/**\n * Whether the failure came back from Postgres rather than from building the\n * query — which decides whether a fallback query is worth issuing.\n *\n * Reads here run inside a transaction (that is where `SET LOCAL ROLE` binds\n * RLS). Once a statement raises, that transaction is aborted, and every later\n * statement on it returns `25P02` — \"current transaction is aborted, commands\n * ignored until end of transaction block\". So a retry after a database error\n * cannot succeed, and it replaces a precise diagnosis (\"invalid input syntax\n * for type uuid\") with a generic one. Rethrow instead.\n *\n * A query the driver could not even build — a missing reciprocal relation, say\n * — never reached Postgres, leaves the transaction usable, and is exactly what\n * the fallback paths exist for.\n */\nexport function reachedDatabase(error: unknown): boolean {\n return extractPgError(error) !== null;\n}\n\n// In its own module so the driver CLI can use it without loading the server\n// (this file imports `@rebasepro/server`).\nexport { extractCauseMessage };\n\n/**\n * Codes that mean \"this connection will never work as configured\".\n *\n * A wrong password or a database that does not exist is a settled fact about\n * the connection string, not a transient fault — retrying produces the same\n * answer forever.\n */\nconst UNRECOVERABLE_CONNECT_CODES = new Set([\n \"28P01\", // invalid_password\n \"28000\", // invalid_authorization_specification\n \"3D000\", // invalid_catalog_name — the database does not exist\n \"42501\" // insufficient_privilege\n]);\n\nexport interface ConnectFailure {\n /** True when retrying cannot help: the connection string itself is wrong. */\n fatal: boolean;\n /** The deepest message available — the Postgres one where there is one. */\n reason: string;\n /** The `SQLSTATE`, when the failure came from Postgres rather than the socket. */\n code?: string;\n}\n\n/**\n * Describe a failed connection attempt in terms a developer can act on.\n *\n * The error a caller catches is Drizzle's wrapper: its message is\n * `Failed query: SELECT 1` and its stack runs through drizzle internals, while\n * the sentence that says what is actually wrong — \"password authentication\n * failed for user …\", \"database … does not exist\" — sits in `.cause`. Logging\n * the wrapper, as the bootstrapper used to, tells a developer with a typo in\n * their `DATABASE_URL` nothing at all.\n */\nexport function classifyConnectFailure(error: unknown): ConnectFailure {\n const pgError = extractPgError(error);\n const reason =\n pgError?.message ??\n extractCauseMessage(error) ??\n (error instanceof Error ? error.message : String(error));\n return {\n fatal: Boolean(pgError?.code && UNRECOVERABLE_CONNECT_CODES.has(pgError.code)),\n reason,\n code: pgError?.code\n };\n}\n\n/**\n * Detect whether an error is specifically a role-switching permission failure\n * (e.g. \"permission denied to set role\" or \"must be member of role\"),\n * as opposed to a table-level permission denial.\n *\n * This is used by the backend driver to auto-disable role switching when the\n * connection user lacks SET ROLE privileges, rather than surfacing a confusing\n * error to the Studio SQL Editor user.\n */\nexport function isRoleSwitchingPermissionError(error: unknown): boolean {\n const pgError = extractPgError(error);\n if (!pgError || pgError.code !== \"42501\") return false;\n const msg = pgError.message.toLowerCase();\n return msg.includes(\"set role\") || msg.includes(\"member of role\");\n}\n\n/**\n * Was this `42501` the *caller* being refused by a policy, rather than the\n * server lacking a privilege?\n *\n * Both arrive as `insufficient_privilege`, and they are opposite kinds of\n * problem. A row-level-security refusal is a working access-control system\n * doing its job: the caller asked for something their policies do not permit,\n * which is a 403 and nobody's bug. A missing `GRANT` is the deployment being\n * wrong — the connection role cannot touch the table at all, no policy is\n * involved, and nothing the caller changes about the request will help.\n *\n * Postgres distinguishes them in the message, so this does too:\n *\n * new row violates row-level security policy for table \"notes\" → the caller\n * permission denied for table notes → the server\n *\n * Only writes reach this. A read that RLS excludes is not an error — the rows\n * are filtered and the caller gets an empty page — so the erroring case is\n * specifically an `INSERT`/`UPDATE` whose row fails a policy's `WITH CHECK`.\n *\n * Matched on the message because that is the only thing carrying the\n * distinction; the SQLSTATE is identical either way. Narrow by design: anything\n * not naming row-level security stays the server's problem, since reporting a\n * genuine privilege misconfiguration as \"forbidden\" would send an operator\n * hunting for a policy bug that does not exist.\n */\nexport function isRowLevelSecurityDenial(error: unknown): boolean {\n const pgError = extractPgError(error);\n if (!pgError || pgError.code !== \"42501\") return false;\n return pgError.message.toLowerCase().includes(\"row-level security policy\");\n}\n\n/**\n * One constraint the database refused, named in the caller's vocabulary.\n *\n * `field` is the **wire** name, derived from the physical column: `author_id`\n * on the table is `authorId` on the row and in the request body, and telling a\n * caller their `author_id` is missing sends them looking for a key their client\n * has never seen. `code` is the SQLSTATE, which is stable, documented by\n * Postgres and the same in every environment — unlike the message, which is\n * deliberately thinner in production.\n *\n * Deliberately no `value`. The column name is safe to publish: it is already in\n * the OpenAPI, the generated SDK and the caller's own request. The *value* is\n * not — `23505`'s detail reads `Key (email)=(a@b.c) already exists.`, which\n * answers \"is this person registered?\" for any address on a table whose rows\n * RLS is otherwise hiding completely.\n */\nexport interface PgFieldViolation {\n field: string;\n code: string;\n}\n\n/**\n * The physical column names a Postgres error is about.\n *\n * Postgres puts one in `column` for `23502` and nowhere else, so the rest are\n * read out of the two places that do carry them:\n *\n * - `detail` — `Key (author_id)=(9) is not present in table \"authors\".` and\n * `Key (email, tenant_id)=(…) already exists.` Only the parenthesised column\n * list is read; the values after `=` are never touched.\n * - `constraint` — `users_email_key`, `posts_author_id_fkey`. The table prefix\n * and the constraint suffix are stripped, leaving the columns joined by `_`,\n * which is ambiguous for multi-column constraints and is therefore only used\n * when `detail` gave nothing.\n *\n * `22P02` carries neither, because an invalid literal fails during parse rather\n * than against a constraint. Its message names the *type*, and an enum type is\n * generated as `<table>_<column>` — which is the one case worth decoding,\n * because a value outside an enum's labels is the most common 22P02 anyone\n * hits and the least legible one.\n */\nfunction offendingColumns(pgError: PostgresError, collection?: CollectionConfig): string[] {\n if (pgError.column) return [pgError.column];\n\n const detail = pgError.detail;\n if (detail) {\n const keyed = /Key \\(([^)]+)\\)=/.exec(detail);\n if (keyed) {\n return keyed[1].split(\",\").map(part => part.trim().replace(/^\"|\"$/g, \"\")).filter(Boolean);\n }\n }\n\n if (pgError.code === \"22P02\") {\n // `invalid input value for enum posts_status: \"archived\"`\n const enumType = /invalid input value for enum ([^:\\s]+)/i.exec(pgError.message ?? \"\");\n if (enumType && collection) {\n const typeName = enumType[1].replace(/^.*\\./, \"\").replace(/\"/g, \"\");\n const table = getTableName(collection);\n if (typeName.startsWith(`${table}_`)) return [typeName.slice(table.length + 1)];\n }\n return [];\n }\n\n const constraint = pgError.constraint;\n if (constraint && collection) {\n const table = getTableName(collection);\n const stripped = constraint\n .replace(new RegExp(`^${table}_`), \"\")\n .replace(/_(pkey|key|fkey|unique|check|excl|idx)$/, \"\");\n // Only when it names something the collection actually has: a\n // hand-written constraint name is not a column list, and guessing at one\n // would put a field in the response that does not exist.\n if (stripped && stripped !== constraint) {\n const columns = new Set<string>();\n for (const [key, prop] of Object.entries(collection.properties ?? {})) {\n columns.add((prop as { columnName?: string })?.columnName ?? key);\n }\n if (columns.has(stripped)) return [stripped];\n const wire = fieldKeyForColumn(collection, stripped);\n if (collection.properties && wire in collection.properties) return [stripped];\n }\n }\n\n return [];\n}\n\n/**\n * The fields a Postgres error is about, for `details.violations`.\n *\n * Only the four SQLSTATEs that describe *the caller's data*: a missing value, a\n * duplicate, a bad literal, a foreign key pointing at nothing. Everything else\n * — a dropped connection, a missing table, a privilege problem — is the\n * deployment's, and naming a field for it would send the reader to the wrong\n * place.\n *\n * Empty when the collection is unknown or the column cannot be recovered. An\n * empty list is the honest answer; inventing a field is worse than saying\n * nothing, because a form will mark the wrong input red.\n */\nexport function pgFieldViolations(\n pgError: PostgresError,\n collection?: CollectionConfig\n): PgFieldViolation[] {\n const code = pgError.code;\n if (code !== \"23502\" && code !== \"23505\" && code !== \"22P02\" && code !== \"23503\") return [];\n // Without the collection there is no mapping, only a guess. `toWireKey`\n // would get the default case right and silently invent a field for any\n // property carrying an explicit `columnName` — and a form pointed at an\n // input that does not exist is worse off than one shown the raw column.\n if (!collection) return [];\n const columns = offendingColumns(pgError, collection);\n if (columns.length === 0) return [];\n return columns.map(column => ({\n field: fieldKeyForColumn(collection, column),\n code\n }));\n}\n\n/**\n * What a missing table or column most often means: the database is behind the\n * collections. Both ways of catching it up, because \"run migrations\" alone\n * sent a project on the managed development database — which nobody\n * migrates — the wrong way.\n */\nconst SCHEMA_BEHIND =\n \"Check that the database is up to date with the collections: `rebase db push` in development, \" +\n \"or `rebase db migrate` where migrations are used.\";\n\n/**\n * Translate a raw PostgreSQL error into a user-friendly message.\n *\n * @param pgError - The extracted PostgreSQL error (from {@link extractPgError})\n * @param context - A human-readable context string (e.g. collection slug or path)\n * @returns An object with a `message` safe for the client and the PG `code`.\n */\nexport function pgErrorToFriendlyMessage(\n pgError: PostgresError,\n context: string,\n options: { verbose?: boolean; collection?: CollectionConfig } = {}\n): { message: string; code: string; violations: PgFieldViolation[] } {\n // Postgres's own `DETAIL` and `HINT`, and the raw driver message, are what\n // make these errors useful while you are building — and what makes them an\n // oracle once the server is answering strangers.\n //\n // The sharp one is `23505`: its detail reads `Key (email)=(a@b.c) already\n // exists.`, which answers \"is this person registered?\" for any address, on\n // a table whose rows RLS is otherwise hiding completely. The rest leak\n // physical column and constraint names, which are the map for the next\n // question. So in production the shape of the failure is served — what\n // rule was broken, and where — and the values are not.\n //\n // The full text is not lost: the caller logs the original error. This\n // decides what crosses the wire, not what is recorded.\n const verbose = options.verbose ?? process.env.NODE_ENV !== \"production\";\n\n const detail = verbose ? (pgError.detail as string | undefined) : undefined;\n const hint = verbose ? (pgError.hint as string | undefined) : undefined;\n const constraint = pgError.constraint as string | undefined;\n const column = pgError.column as string | undefined;\n const table = pgError.table as string | undefined;\n const dataType = verbose ? (pgError.dataType as string | undefined) : undefined;\n const rawMessage = pgError.message || \"Unknown database error\";\n const pgMessage = verbose ? rawMessage : \"\";\n const code = pgError.code || \"UNKNOWN\";\n\n // Which *field* the caller has to fix, derived from the column. Safe in\n // production — a column name is already published in the OpenAPI and the\n // generated SDK — where the value that broke the rule is not, and is never\n // included. See `pgFieldViolations`.\n const violations = pgFieldViolations(pgError, options.collection);\n\n const suffix = hint ? ` Hint: ${hint}` : \"\";\n const tableRef = table ?? context;\n\n /** `\": <postgres said>\"`, or nothing when the details are withheld. */\n const said = pgMessage ? `: ${pgMessage}` : \"\";\n\n switch (pgError.code) {\n case \"23503\": // foreign_key_violation\n return {\n message: detail\n ? `Foreign key constraint violated: ${detail}${suffix}`\n : `Cannot complete operation: a foreign key constraint${constraint ? ` (${constraint})` : \"\"} was violated in \"${context}\".${suffix}`,\n code,\n violations\n };\n case \"23001\": // restrict_violation\n // A row other rows still point at, under `ON DELETE RESTRICT` — the\n // default for a required link. `table` is the *referencing* table,\n // which is the one the caller has to clear or reassign first.\n return {\n message: `Cannot complete operation: rows in \"${table ?? \"another table\"}\" still reference this row in ` +\n `\"${context}\", and their foreign key${constraint ? ` (${constraint})` : \"\"} does not allow it to be ` +\n `deleted or its key changed. Delete or reassign those rows first.${detail ? ` ${detail}` : \"\"}${suffix}`,\n code,\n violations\n };\n case \"23505\": // unique_violation\n return {\n message: detail\n ? `Duplicate value: ${detail}${suffix}`\n : `Cannot complete operation: a unique constraint${constraint ? ` (${constraint})` : \"\"} was violated in \"${context}\".${suffix}`,\n code,\n violations\n };\n case \"23502\": {\n // not_null_violation. The message names the *field* when the\n // collection is known, because that is the key the caller sent and\n // the only one they can act on: told `author_id` is missing, they go\n // looking for a key their generated client has never mentioned.\n const named = violations[0]?.field ?? column ?? \"unknown\";\n return {\n message: `Missing required field: \"${named}\" in \"${tableRef}\" cannot be empty.${suffix}`,\n code,\n violations\n };\n }\n case \"23514\": // check_violation\n return {\n message: `Validation failed: a check constraint${constraint ? ` (${constraint})` : \"\"} was violated in \"${context}\".${suffix}`,\n code,\n violations\n };\n case \"22P02\": // invalid_text_representation (e.g. invalid UUID, wrong enum value)\n return {\n message: `Invalid data format in \"${context}\"${said}.${suffix}`,\n code,\n violations\n };\n case \"22001\": // string_data_right_truncation (value too long)\n return {\n message: `Value too long for column \"${column ?? \"unknown\"}\" in \"${tableRef}\"${said}.${suffix}`,\n code,\n violations\n };\n case \"22003\": // numeric_value_out_of_range\n return {\n message: `Numeric value out of range for column \"${column ?? \"unknown\"}\" in \"${tableRef}\"${said}.${suffix}`,\n code,\n violations\n };\n case \"42703\": // undefined_column\n return {\n message: `Unknown column in \"${tableRef}\"${said}. ${SCHEMA_BEHIND}${suffix}`,\n code,\n violations\n };\n case \"42P01\": // undefined_table\n return {\n message: `Table not found for \"${context}\"${said}. ${SCHEMA_BEHIND}${suffix}`,\n code,\n violations\n };\n case \"42501\": // insufficient_privilege\n // Two unrelated failures share this SQLSTATE, and the old message\n // named both causes because it could not tell them apart — which\n // meant it was half wrong whichever one had happened, and sent the\n // reader to check the other. Postgres says which in its own message.\n return rawMessage.toLowerCase().includes(\"row-level security policy\")\n ? {\n // The caller. Their policies do not permit this row; the\n // deployment is working exactly as configured.\n message: `Not permitted to write this row in \"${tableRef}\": it does not satisfy the row-level security policy.${suffix}`,\n code,\n violations\n }\n : {\n // The deployment. No policy is involved — the connecting\n // role cannot touch the table at all.\n message: `Permission denied on \"${tableRef}\": the database role this server connects as lacks privileges on it.${suffix}`,\n code,\n violations\n };\n case \"28000\": // invalid_authorization_specification\n return {\n message: `Authorization failed for \"${context}\". Check your database credentials.${suffix}`,\n code,\n violations\n };\n default: {\n // Unhandled PG code — still surface the actual database message\n const parts = [`Database error in \"${context}\" [${code}]${said}`];\n if (detail) parts.push(`Detail: ${detail}`);\n if (column) parts.push(`Column: ${column}`);\n if (dataType) parts.push(`Data type: ${dataType}`);\n if (constraint) parts.push(`Constraint: ${constraint}`);\n if (hint) parts.push(`Hint: ${hint}`);\n return { message: parts.join(\". \"), code, violations };\n }\n }\n}\n\n/**\n * Sanitize any error into a message safe and helpful for the client.\n *\n * A deliberate 4xx (`ApiError`) passes through untouched — the server already\n * decided what the client should read. Otherwise the PG error is extracted\n * from the Drizzle cause chain, falling back to a generic message that\n * doesn't leak SQL.\n *\n * @param error - The raw caught error\n * @param context - A human-readable context string (e.g. collection path)\n * @returns An object with `message` (user-friendly) and optional `code`\n * (the `ApiError` code, or the PG SQLSTATE).\n */\nexport function sanitizeErrorForClient(\n error: unknown,\n context: string,\n options: { collection?: CollectionConfig } = {}\n): { message: string; code?: string; violations?: PgFieldViolation[] } {\n // ── A deliberate 4xx is not a database failure ──────────────────\n // Its message and code are written for the client; replacing them with\n // \"Check server logs\" would discard the only diagnosis the caller gets\n // (e.g. the offending filter field and the collection's valid ones).\n // Log level follows the same convention as the HTTP error handler in\n // @rebasepro/server: routine outcomes at debug, everything else at warn.\n const clientError = asClientFacingError(error);\n if (clientError) {\n const line = `[API ${clientError.statusCode} ${clientError.code ?? \"BAD_REQUEST\"}] in \"${context}\": ${clientError.message}`;\n if (clientError.expected) {\n logger.debug(line);\n } else {\n logger.warn(`⚠️ ${line}`);\n }\n return { message: clientError.message, ...(clientError.code && { code: clientError.code }) };\n }\n\n // ── The database unreachable: the answer every door gives then ──\n // Ahead of the SQLSTATE arm, because `57P01` is a SQLSTATE that says the\n // connection is gone rather than that the statement was wrong.\n if (isDatabaseUnreachable(error)) {\n logger.warn(`[DB] The database is unreachable; \"${context}\" could not be read`);\n return { message: DATABASE_UNAVAILABLE_MESSAGE, code: \"DATABASE_UNAVAILABLE\" };\n }\n\n // ── Always log the full, unsanitized error server-side ──────────\n const pgError = extractPgError(error);\n\n if (pgError) {\n logger.error(`[PG ${pgError.code}] Error in \"${context}\"`, {\n code: pgError.code,\n message: pgError.message,\n detail: pgError.detail,\n hint: pgError.hint,\n column: pgError.column,\n table: pgError.table,\n constraint: pgError.constraint,\n dataType: pgError.dataType\n // The outer Drizzle wrapper message used to be logged here \"for\n // full context\": it is `Failed query: <sql>\\nparams: <values>`, so\n // it published the statement and every bound value (an email, a\n // password hash) on every realtime data failure. The SQLSTATE,\n // detail, table, column and constraint above are the diagnostic\n // value; the wrapper added only the leak. `logger` strips the\n // wrapper as well, but the field itself carried nothing else.\n });\n const { message, code, violations } = pgErrorToFriendlyMessage(pgError, context, { collection: options.collection });\n return { message, code, ...(violations.length > 0 && { violations }) };\n }\n\n // No PG error found — log the raw error as-is\n logger.error(`Database error in \"${context}\" (no PG error extracted)`, {\n error: error instanceof Error ? error.message : String(error),\n stack: error instanceof Error ? error.stack : undefined,\n cause: error instanceof Error && error.cause\n ? (error.cause instanceof Error ? error.cause.message : String(error.cause))\n : undefined\n });\n\n // Try to get the deepest cause message\n const causeMessage = extractCauseMessage(error);\n if (causeMessage) {\n return { message: `Database error in \"${context}\": ${causeMessage}` };\n }\n\n // Last resort — generic message, never leak raw SQL\n return { message: `Could not load data for \"${context}\". Check server logs for details.` };\n}\n"],"mappings":"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"}
@@ -500,6 +500,32 @@ var compileSecurityRule = (collection, rule, resolveCollection, injected, ruleKe
500
500
  }));
501
501
  };
502
502
  /**
503
+ * Refuse two of a table's policies that Postgres would store under one name.
504
+ *
505
+ * Each policy is rendered as `DROP POLICY IF EXISTS "<name>"` and then its
506
+ * `CREATE`, and Postgres keeps the first 63 bytes of the name, so the second
507
+ * of two policies whose names share those bytes drops the first and takes its
508
+ * place. On a table of 56 bytes or more every unnamed rule of one operation is
509
+ * `<table>_<op>` once stored, so a restrictive gate followed by a grant left
510
+ * the grant alone in force. One rule's own operations never collide here —
511
+ * `getPolicyNamesForRule` names them apart — so a collision is always two
512
+ * rules, and the author names one of them.
513
+ */
514
+ var sameStoredPolicy = (a, b) => a.name === b.name && a.operation === b.operation && a.mode === b.mode && a.roles.join(",") === b.roles.join(",") && a.using === b.using && a.withCheck === b.withCheck;
515
+ function assertDistinctStoredPolicyNames(policies) {
516
+ const owners = /* @__PURE__ */ new Map();
517
+ for (const policy of policies) {
518
+ const stored = toPostgresIdentifier(policy.name);
519
+ const first = owners.get(stored);
520
+ if (!first) {
521
+ owners.set(stored, policy);
522
+ continue;
523
+ }
524
+ if (sameStoredPolicy(first, policy)) continue;
525
+ throw new Error(`The security rules "${first.ruleKey}" and "${policy.ruleKey}" compile to the policies "${first.name}" and "${policy.name}", which Postgres stores under one name, "${stored}": it keeps only the first 63 bytes of an identifier, so the second would replace the first. Give one of the rules a shorter \`name\`, or the collection a shorter \`table\`.`);
526
+ }
527
+ }
528
+ /**
503
529
  * A table's policies, minus any superseded name Postgres would store one of
504
530
  * them under.
505
531
  *
@@ -510,6 +536,7 @@ var compileSecurityRule = (collection, rule, resolveCollection, injected, ruleKe
510
536
  * POLICY IF EXISTS` already removes the old policy, so nothing is lost.
511
537
  */
512
538
  var withoutLiveSupersededNames = (policies) => {
539
+ assertDistinctStoredPolicyNames(policies);
513
540
  const stored = new Set(policies.map((policy) => toPostgresIdentifier(policy.name)));
514
541
  return policies.map((policy) => {
515
542
  if (!policy.supersedes) return policy;
@@ -1405,4 +1432,4 @@ function planRelations(collections, tableEntries) {
1405
1432
  //#endregion
1406
1433
  export { triggerStatements as a, SET_UPDATED_AT_FN as i, planSchema as n, sharedRelationName as o, quoteSqlLiteral as r, columnPgType as t };
1407
1434
 
1408
- //# sourceMappingURL=plan-schema-YagMlmNE.js.map
1435
+ //# sourceMappingURL=plan-schema-DMVh77yb.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"plan-schema-DMVh77yb.js","names":[],"sources":["../src/schema/relation-names.ts","../src/schema/plan/updated-at-trigger.ts","../src/schema/plan/plan-schema.ts"],"sourcesContent":["import { CollectionConfig, ResolvedRelation } from \"@rebasepro/types\";\nimport { fieldKeyForColumn, getTableName } from \"@rebasepro/common\";\nimport { toSnakeCase } from \"@rebasepro/utils\";\n\n/**\n * The `relationName` both sides of a link must agree on.\n *\n * Drizzle pairs an owning `one()` with its inverse `many()` by this string and\n * by nothing else, and the two sides are computed by different callers holding\n * different collections — so the rule has to be derivable from either end. It\n * is: name the link after the table that carries the foreign key and the field\n * key that column is served under.\n *\n * owning (belongsTo) → `{thisTable}_{fieldKey(localKey)}`\n * inverse (hasMany/hasOne) → `{targetTable}_{fieldKey(foreignKeyOnTarget)}`\n *\n * Both spellings of `jobs.company` produce `jobs_companyId`. A many-to-many is\n * named through its junction wiring and a `via` chain is not a Drizzle relation\n * at all, so both keep the local name.\n *\n * The field key rather than the column: the Drizzle object is keyed by the wire\n * name (`fieldKeyForColumn` is the one definition of it), and a name built from\n * the column would differ between a collection that declares `columnName` and\n * one that does not, for the same link.\n *\n * **This is the one definition.** `generate-drizzle-schema-logic.ts` holds a\n * private copy (`computeSharedRelationName`) that this was lifted from verbatim;\n * the generator should import this instead, so the file it writes and the\n * relations the runtime builds from the live catalogue cannot drift apart.\n */\nexport function sharedRelationName(\n relation: ResolvedRelation,\n sourceCollection: CollectionConfig\n): string {\n const fallback = (): string => {\n if (relation.relationName) return relation.relationName;\n try {\n return toSnakeCase(relation.target().slug);\n } catch {\n return relation.relationName;\n }\n };\n\n if (relation.kind === \"belongsTo\") {\n return `${getTableName(sourceCollection)}_${fieldKeyForColumn(sourceCollection, relation.localKey)}`;\n }\n\n if (relation.kind === \"hasMany\" || relation.kind === \"hasOne\") {\n try {\n const target = relation.target();\n return `${getTableName(target)}_${fieldKeyForColumn(target, relation.foreignKeyOnTarget)}`;\n } catch {\n return fallback();\n }\n }\n\n return fallback();\n}\n","/**\n * `autoValue: \"on_update\"`, as a database trigger.\n *\n * ## Why a trigger and not only the driver\n *\n * The driver stamps `updated_at` on every write it makes, and it has to keep\n * doing so: a `beforeSave` hook reads the row it is about to persist, and a\n * value that only appears once Postgres has written it is a value the hook\n * cannot see.\n *\n * But the driver is not the only writer. A seed script, a migration backfill, a\n * `psql` session, an admin fixing one row by hand — every one of those leaves\n * `updated_at` at whatever it was, and the column then says the row has not\n * changed since a date that is simply wrong. Anything reading it to decide what\n * to re-index, re-sync or re-send skips the row. The declaration says \"this\n * column tracks the last write\"; only the database can make that true.\n *\n * So both: the app stamps so hooks see the value, and a `BEFORE UPDATE` trigger\n * stamps so every other writer does too. They agree because they both mean\n * \"now\" — the trigger's `now()` is the transaction's start time, which is the\n * same instant the driver's own timestamp is written under.\n *\n * ## Why it is carved out of Atlas\n *\n * Atlas's free tier refuses to *parse* a desired-state file containing a\n * function (\"functions and procedures are available to logged-in users only\"),\n * and a trigger is a function plus a binding. This is the same arrangement the\n * search helpers already have: excluded from Atlas's view by pattern, written\n * to a file Rebase applies itself, applied at boot by the schema ensure, and\n * appended to migrations by the CLI so a replay is complete.\n *\n * ## Why one function for every column\n *\n * The column name arrives as a trigger argument (`TG_ARGV[0]`), so a project\n * with forty `updated_at` columns installs one function and forty bindings\n * rather than forty near-identical functions. `jsonb_populate_record(NEW, …)`\n * is the documented way to set a field of a row whose type is not known until\n * run time; it takes `NEW` as the row template, so the value is cast back to\n * whatever the column actually is — a `timestamptz`, or a `date` if that is\n * what the property declared.\n */\nimport { REBASE_SCHEMA } from \"@rebasepro/types\";\nimport type { TriggerPlan } from \"./types\";\n\n/** The one trigger function, qualified. A frozen derived name. */\nexport const SET_UPDATED_AT_FN = `${REBASE_SCHEMA}.set_updated_at`;\n\n/**\n * `CREATE OR REPLACE FUNCTION`, so replaying it against a database that already\n * has it is a no-op — this is emitted into a file that runs on every push and\n * is appended to migrations that run against databases at any stage of life.\n */\nexport const setUpdatedAtFunction = (): string =>\n `CREATE OR REPLACE FUNCTION ${SET_UPDATED_AT_FN}() RETURNS trigger\\n` +\n \"LANGUAGE plpgsql AS $$\\n\" +\n \"BEGIN\\n\" +\n \" NEW := jsonb_populate_record(NEW, jsonb_build_object(TG_ARGV[0], now()));\\n\" +\n \" RETURN NEW;\\n\" +\n \"END;\\n\" +\n \"$$;\";\n\n/**\n * `DROP TRIGGER IF EXISTS` before the `CREATE`.\n *\n * `CREATE OR REPLACE TRIGGER` exists only on Postgres 14+, and this runs\n * against whatever a self-hosted project points at. Two statements rather than\n * one is also what the boot-time applier needs: it issues DDL one statement at\n * a time over the extended query protocol, which forbids multiple commands in\n * one execute.\n */\nexport const dropTriggerStatement = (plan: TriggerPlan): string =>\n `DROP TRIGGER IF EXISTS \"${plan.name}\" ON \"${plan.schema}\".\"${plan.table}\";`;\n\nexport const createTriggerStatement = (plan: TriggerPlan): string =>\n `CREATE TRIGGER \"${plan.name}\" BEFORE UPDATE ON \"${plan.schema}\".\"${plan.table}\" ` +\n `FOR EACH ROW EXECUTE FUNCTION ${SET_UPDATED_AT_FN}('${plan.column.replace(/'/g, \"''\")}');`;\n\n/** Both statements, in the order they must run. */\nexport const triggerStatements = (plan: TriggerPlan): string[] =>\n [dropTriggerStatement(plan), createTriggerStatement(plan)];\n","/**\n * The only place a `Property` is read for schema purposes.\n *\n * Everything that used to `switch (prop.type)` — the Drizzle generator, the DDL\n * generator, the boot-time ensure — now renders the {@link SchemaPlan} this\n * produces. See `./types.ts` for why.\n *\n * Pure and synchronous. It reads collections and nothing else: no database, no\n * filesystem, no process-wide registry. The one fact about the world it needs\n * (which extensions a project's databases gave Rebase leave to install) is\n * passed in, because a plan that depended on whatever module happened to be\n * imported would not be comparable with itself.\n *\n * It **throws** rather than guessing. A configuration no renderer can honour —\n * an empty enum, `isId: \"cuid\"`, a foreign key into a composite key, an unknown\n * `columnType`, a relation to a collection that is not in the bundle, a\n * `search` block on a collection Postgres does not store — used to fail\n * differently in each of the three emitters, or not at all, and the failure\n * landed at `CREATE TABLE` time on a managed tenant with nobody in the loop.\n * Here it lands once, with the collection and the property named.\n */\nimport {\n isPostgresCollectionConfig,\n isManyToMany,\n REBASE_SCHEMA,\n type ArrayProperty,\n type CollectionConfig,\n type DateProperty,\n type MapProperty,\n type NumberProperty,\n type Properties,\n type Property,\n type ReferenceProperty,\n type RelationProperty,\n type ResolvedForeignKeyOnTarget,\n type ResolvedRelation,\n type SecurityRule,\n type StringProperty,\n type VectorProperty,\n hasForeignKeyOnTarget\n} from \"@rebasepro/types\";\nimport {\n fieldKeyForColumn,\n findRelation,\n getEffectiveSecurityRules,\n getEnumVarName,\n getInjectedSecurityRules,\n getTenantConfig,\n TENANT_INDEX_REASON,\n getJunctionCollectionConfig,\n getJunctionSecurityRules,\n getTableName,\n type JunctionSpec,\n getTableVarName,\n compileRulePolicies,\n relationalCollections,\n resolveCollectionRelations,\n resolveJunctionSpecs,\n assertBeforeQueryIsPostgresOnly,\n resolveStringColumnLength\n} from \"@rebasepro/common\";\nimport {\n generateForeignKeyName,\n getPolicySupersededNames,\n legacyForeignKeyName,\n toPostgresIdentifier,\n toSnakeCase\n} from \"@rebasepro/utils\";\nimport {\n declaresEnumType,\n enumLabelsOf,\n getPrimaryKeyColumn,\n getPrimaryKeyName,\n getPrimaryKeyProp,\n idColumnDefault,\n isIdProperty,\n primaryKeyPropertyNames,\n resolveColumnName,\n sqlExpressionText\n} from \"../column-plan-helpers\";\nimport {\n AUTH_USERS_COLUMNS,\n authUsersColumnDefinition,\n authUsersColumnSql,\n isAuthCollection\n} from \"../auth-users-columns\";\nimport {\n assertSearchIsPostgresOnly,\n buildSearchColumnSpec,\n searchColumnTypeSql,\n searchExtensionStatements,\n searchHelperFunctions\n} from \"../search-column\";\nimport {\n buildVectorColumnSpecs,\n buildVectorIndexPlan,\n vectorExtensionDeclared,\n vectorExtensionStatement\n} from \"../vector-index\";\nimport {\n buildCollectionIndexSpecs,\n deriveIndexName,\n foreignKeyIndexSpec,\n leadsWithColumn,\n type CollectionIndexSpec\n} from \"../collection-index\";\nimport { sharedRelationName } from \"../relation-names\";\nimport { SET_UPDATED_AT_FN, setUpdatedAtFunction } from \"./updated-at-trigger\";\nimport type {\n ColumnDefault,\n ColumnPlan,\n EnumPlan,\n ForeignKeyPlan,\n PgType,\n PlanOptions,\n PolicyPlan,\n RelationPlan,\n SchemaPlan,\n TablePlan,\n TriggerPlan\n} from \"./types\";\n\ntype ResolveCollection = (slug: string) => CollectionConfig | undefined;\n\n/**\n * Single-quote escaping for a SQL string literal (PostgreSQL doubles the\n * quote). Enum labels and `defaultValue`s come straight from user-authored\n * collection config, so a value like `it's` closes the literal early and the\n * whole generated file stops parsing at that statement.\n */\nexport const quoteSqlLiteral = (value: string): string => `'${value.replace(/'/g, \"''\")}'`;\n\nconst schemaOf = (collection: CollectionConfig): string =>\n isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : \"public\";\n\nconst bareTableName = (name: string): string => (name.includes(\".\") ? name.split(\".\").pop()! : name);\n\nconst describe = (collection: CollectionConfig): string =>\n collection.slug ?? collection.name ?? \"(unnamed)\";\n\n/** A link, as a refusal names it: `relation \"posts.author\"`. */\nconst linkLabel = (kind: string, collection: CollectionConfig, key: string): string =>\n `${kind} \"${describe(collection)}.${key}\"`;\n\n/**\n * The `ON DELETE` a foreign key gets when the author did not say.\n *\n * One rule for every property that emits one — `belongsTo` relations and\n * `reference` properties alike. `reference` kept its own `CASCADE` default for\n * a release after this rule was written, which is exactly the split this\n * function exists to prevent: two spellings of the same link, two\n * data-retention behaviours, and only one of them documented.\n *\n * An optional link is `SET NULL`: the column can hold NULL, so dropping the\n * parent leaves the child row with an empty pointer, which is what \"optional\"\n * already means.\n *\n * A required link is **`RESTRICT`**, not `CASCADE`. `NOT NULL` says the child\n * cannot exist without a parent; it does not say deleting the parent should\n * take the child with it. That second claim is a data-retention decision, and\n * defaulting to it meant `onDelete` — a field nobody has to write — silently\n * turned every `DELETE FROM authors` into a cascade through posts, comments and\n * anything else that hung off them.\n */\nexport const defaultBelongsToOnDelete = (required: boolean | undefined): \"RESTRICT\" | \"SET NULL\" =>\n required ? \"RESTRICT\" : \"SET NULL\";\n\nconst foreignKeyPlan = (\n args: Omit<ForeignKeyPlan, \"constraintName\" | \"sql\">\n): ForeignKeyPlan => {\n const constraintName = toPostgresIdentifier(`${args.table}_${args.column}_fkey`);\n const onUpdate = args.onUpdate ? ` ON UPDATE ${args.onUpdate.toUpperCase()}` : \"\";\n return {\n ...args,\n constraintName,\n sql:\n `ALTER TABLE \"${args.schema}\".\"${args.table}\" ADD CONSTRAINT \"${constraintName}\" ` +\n `FOREIGN KEY (\"${args.column}\") REFERENCES \"${args.targetSchema}\".\"${args.targetTable}\" ` +\n `(\"${args.targetColumn}\") ON DELETE ${args.onDelete.toUpperCase()}${onUpdate}`\n };\n};\n\n// ── Types ────────────────────────────────────────────────────────────────────\n\n/**\n * The type a column pointing at this collection's primary key must have — a\n * junction endpoint, a `belongsTo` foreign key, a `reference`.\n *\n * The key's own column type, from the same functions that typed the key: a\n * foreign key only holds between compatible types, so any second reading of\n * the key is a constraint waiting to fail. This used to look at the id\n * strategy alone, so `id: { isId: true, columnType: \"uuid\" }` was referenced by\n * TEXT columns (42804 — the constraint was never created) and a `bigint` key by\n * INTEGER ones, which overflow at 2^31.\n *\n * One exception: a `serial` key owns a sequence, and a column pointing at it is\n * the plain integer of the same width — `SERIAL` there would give every\n * referencing column a sequence of its own.\n *\n * @param via the link asking, named if the collection's key is composite and so\n * cannot be pointed at — see `getPrimaryKeyProp`.\n */\nexport const primaryKeyPgType = (collection: CollectionConfig, via: string): PgType => {\n const { name, prop } = getPrimaryKeyProp(collection, via);\n if (prop?.type === \"number\") {\n return withoutSequence(numberType(name, prop as NumberProperty, collection, true));\n }\n if (prop?.type === \"string\") return stringType(name, prop as StringProperty, collection);\n // The implicit `id TEXT PRIMARY KEY` of a collection that declares no key.\n return { kind: \"text\" };\n};\n\n/**\n * The DEFAULT of the implicit `id TEXT PRIMARY KEY` a collection that declares\n * no key gets: a uuid, as text. The same generator `isId: \"uuid\"` uses, cast to\n * the column the key has always been.\n */\nexport const IMPLICIT_ID_DEFAULT = \"gen_random_uuid()::text\";\n\nconst withoutSequence = (type: PgType): PgType => {\n switch (type.kind) {\n case \"smallserial\": return { kind: \"smallint\" };\n case \"serial\": return { kind: \"integer\" };\n case \"bigserial\": return { kind: \"bigint\" };\n default: return type;\n }\n};\n\n/** The `columnType`s a `number` property may name, and what each one is. */\nconst NUMBER_COLUMN_TYPES: Record<string, PgType> = {\n \"integer\": { kind: \"integer\" },\n // `smallint` and `smallserial` are not in `NumberProperty[\"columnType\"]`'s\n // union, and both have always reached the database: the DDL generator\n // upper-cased whatever it was given. Accepted here for that reason and\n // listed on purpose — the point of this table is that an unrecognised\n // `columnType` is refused with the property named rather than passed\n // through to fail at `CREATE TABLE`.\n \"smallint\": { kind: \"smallint\" },\n \"smallserial\": { kind: \"smallserial\" },\n \"bigint\": { kind: \"bigint\" },\n \"serial\": { kind: \"serial\" },\n \"bigserial\": { kind: \"bigserial\" },\n \"real\": { kind: \"real\" },\n \"double precision\": { kind: \"doublePrecision\" },\n \"numeric\": { kind: \"numeric\" }\n};\n\nconst numberType = (propName: string, prop: NumberProperty, collection: CollectionConfig, isId: boolean): PgType => {\n // An identity column is INTEGER, and `columnType` is not read beside it, on\n // purpose: it is the type every identity key in the field was created with,\n // and every column pointing at one takes it too (`primaryKeyPgType`). The\n // Drizzle generator used to honour `columnType` here while the DDL one\n // ignored it, so the same property was int8 in `schema.generated.ts` and\n // int4 in the database; with `columnType: \"bigserial\"` the emitted\n // `.generatedByDefaultAsIdentity()` is not a method that exists, so the file\n // did not compile at all.\n if (prop.isId === \"increment\") return { kind: \"integer\" };\n if (prop.columnType) {\n const mapped = NUMBER_COLUMN_TYPES[prop.columnType];\n if (!mapped) {\n throw new Error(\n `Property \"${propName}\" of collection \"${describe(collection)}\" declares ` +\n `\\`columnType: \"${prop.columnType}\"\\`, which is not a Postgres numeric type Rebase emits. ` +\n `Use one of: ${Object.keys(NUMBER_COLUMN_TYPES).join(\", \")}.`\n );\n }\n if (mapped.kind === \"numeric\") return numericType(prop);\n return mapped;\n }\n if (prop.validation?.integer || isId) return { kind: \"integer\" };\n return numericType(prop);\n};\n\n/** `NUMERIC`, with the precision and scale the property asks for. */\nconst numericType = (prop: NumberProperty): PgType => {\n const { precision, scale } = prop;\n if (precision === undefined) return { kind: \"numeric\" };\n return scale === undefined\n ? { kind: \"numeric\", precision }\n : { kind: \"numeric\", precision, scale };\n};\n\nconst stringType = (propName: string, prop: StringProperty, collection: CollectionConfig): PgType => {\n if (prop.enum) {\n // Throws on an empty list rather than naming a type nothing creates —\n // the column type and the `CREATE TYPE` come from one reading of `enum`.\n const labels = enumLabelsOf(propName, prop as Property, collection);\n const table = getTableName(collection);\n const column = resolveColumnName(propName, prop as Property);\n return {\n kind: \"enum\",\n schema: schemaOf(collection),\n name: `${table}_${column}`,\n varName: getEnumVarName(table, propName),\n labels\n };\n }\n if (prop.isId === \"uuid\" || prop.columnType === \"uuid\") return { kind: \"uuid\" };\n // The width comes from `validation.max` when the property states one. It\n // used to be a hardcoded 255 in the DDL generator and *absent* on the\n // Drizzle path, so the same property produced a bounded column down one\n // generator and an unbounded one down the other.\n if (prop.columnType === \"char\") return { kind: \"char\", length: resolveStringColumnLength(prop) };\n if (prop.columnType === \"varchar\") return { kind: \"varchar\", length: resolveStringColumnLength(prop) };\n if (prop.columnType !== undefined && prop.columnType !== \"text\") {\n throw new Error(\n `Property \"${propName}\" of collection \"${describe(collection)}\" declares ` +\n `\\`columnType: \"${String(prop.columnType)}\"\\`, which is not a Postgres string type Rebase emits. ` +\n \"Use one of: text, varchar, char, uuid.\"\n );\n }\n // `text` is the default, and the only length-unbounded choice.\n return { kind: \"text\" };\n};\n\nconst arrayElementType = (prop: ArrayProperty): PgType | undefined => {\n let colType = prop.columnType;\n if (!colType && prop.of && !Array.isArray(prop.of)) {\n const of = prop.of as Property;\n if (of.type === \"string\") colType = \"text[]\";\n else if (of.type === \"number\") colType = of.validation?.integer ? \"integer[]\" : \"numeric[]\";\n else if (of.type === \"boolean\") colType = \"boolean[]\";\n }\n switch (colType) {\n case \"text[]\": return { kind: \"text\" };\n case \"integer[]\": return { kind: \"integer\" };\n case \"boolean[]\": return { kind: \"boolean\" };\n case \"numeric[]\": return { kind: \"numeric\" };\n default: return undefined;\n }\n};\n\n/**\n * The Postgres type a property's column has.\n *\n * Every member of `DataType` has an arm. A type this does not know is a\n * generator that has not been taught it yet, and it says so — a silent `TEXT`\n * here is how `geopoint` ended up with a database column, no Drizzle key, and\n * every write to it discarded with a 201.\n */\nexport const columnPgType = (\n propName: string,\n prop: Property,\n collection: CollectionConfig,\n resolveCollection: ResolveCollection\n): PgType => {\n switch (prop.type) {\n case \"string\":\n return stringType(propName, prop as StringProperty, collection);\n case \"number\":\n return numberType(propName, prop as NumberProperty, collection, isIdProperty(propName, prop, collection));\n case \"boolean\":\n return { kind: \"boolean\" };\n case \"date\": {\n const dateProp = prop as DateProperty;\n if (dateProp.columnType === \"date\") return { kind: \"date\" };\n if (dateProp.columnType === \"time\") return { kind: \"time\" };\n return { kind: \"timestamptz\" };\n }\n case \"map\":\n return (prop as MapProperty).columnType === \"json\" ? { kind: \"json\" } : { kind: \"jsonb\" };\n // `{ latitude, longitude }` — a document, like `map`.\n case \"geopoint\":\n return { kind: \"jsonb\" };\n case \"array\": {\n const arrayProp = prop as ArrayProperty;\n if (arrayProp.columnType === \"json\") return { kind: \"json\" };\n const element = arrayElementType(arrayProp);\n return element ? { kind: \"array\", of: element } : { kind: \"jsonb\" };\n }\n case \"vector\":\n return { kind: \"vector\", dimensions: (prop as VectorProperty).dimensions };\n case \"binary\":\n return { kind: \"bytea\" };\n case \"relation\":\n case \"reference\": {\n const target = linkTarget(propName, prop, collection, resolveCollection);\n return target ? primaryKeyPgType(target, linkLabel(prop.type, collection, propName)) : { kind: \"text\" };\n }\n default:\n throw new Error(\n `No Postgres column type for property \"${propName}\" of type ` +\n `\"${(prop as Property).type}\" in collection \"${describe(collection)}\". ` +\n \"Add a case to `columnPgType` in schema/plan/plan-schema.ts.\"\n );\n }\n};\n\n/** The collection a `relation` or `reference` points at, when it resolves. */\nconst linkTarget = (\n propName: string,\n prop: Property,\n collection: CollectionConfig,\n resolveCollection: ResolveCollection\n): CollectionConfig | undefined => {\n if (prop.type === \"reference\") {\n const path = (prop as ReferenceProperty).path;\n return path ? resolveCollection(path) : undefined;\n }\n const relProp = prop as RelationProperty;\n const relation = findRelation(resolveCollectionRelations(collection), relProp.relation?.relationName ?? propName);\n if (relation?.kind !== \"belongsTo\") return undefined;\n try {\n return relation.target();\n } catch {\n return undefined;\n }\n};\n\n// ── Defaults ─────────────────────────────────────────────────────────────────\n\n/** A value already written as a day, or as a time of day. */\nconst BARE_DATE = /^\\d{4}-\\d{2}-\\d{2}$/;\nconst BARE_TIME = /^\\d{2}:\\d{2}(:\\d{2}(\\.\\d+)?)?$/;\n\n/**\n * A date default in the shape its column's type accepts: a day for `date`, a\n * time of day for `time`, an instant for a timestamp.\n *\n * Rendered as a full ISO timestamp whatever the column, a `time` column's\n * DEFAULT was `'2024-03-01T15:30:00.000Z'`, which Postgres refuses — \"invalid\n * input syntax for type time\" — so the schema would not apply. A value already\n * written in the column's shape (`\"2024-12-25\"`, `\"09:00\"`) is kept as written;\n * anything else is read as an instant and its UTC day or time of day taken, the\n * same zone the timestamp rendering has always used. A string that is no date\n * at all is no DEFAULT, rather than a schema that cannot be applied.\n */\nconst dateDefaultLiteral = (value: unknown, type: PgType): string | undefined => {\n if (typeof value === \"string\") {\n if (type.kind === \"date\" && BARE_DATE.test(value)) return value;\n if (type.kind === \"time\" && BARE_TIME.test(value)) return value;\n }\n const instant = value instanceof Date ? value : typeof value === \"string\" ? new Date(value) : undefined;\n if (!instant || Number.isNaN(instant.getTime())) return undefined;\n const iso = instant.toISOString();\n if (type.kind === \"date\") return iso.slice(0, 10);\n if (type.kind === \"time\") return iso.slice(11, 23);\n // A timestamp keeps a string default as it was written — its own offset\n // included — and a Date as the instant it is.\n return typeof value === \"string\" ? value : iso;\n};\n\n/**\n * A `defaultValue` as a database DEFAULT.\n *\n * `defaultValue` reached neither the schema nor — until recently — the write\n * path, so a documented, type-checked field did nothing at all: the panel\n * pre-filled it, an insert from anywhere else (the REST API, a seed, psql) did\n * not, and the column came out NULL. A DEFAULT is the one place that binds\n * every writer.\n *\n * Only literals. A `reference`'s default is an `EntityReference` object and a\n * `vector`'s is an embedding — neither is a column literal, and inventing one\n * would be a value the write path and the database disagree about.\n * `undefined` for those, which is what \"no DEFAULT\" means everywhere here.\n */\nconst literalDefault = (prop: Property, type: PgType): ColumnDefault | undefined => {\n const value = (prop as { defaultValue?: unknown }).defaultValue;\n if (value === undefined || value === null) return undefined;\n\n switch (prop.type) {\n case \"string\":\n // An enum default is its id, which is exactly the label the type\n // carries — the same string the write path stores.\n return typeof value === \"string\" ? { kind: \"literal\", value, sql: quoteSqlLiteral(value) } : undefined;\n case \"number\":\n return typeof value === \"number\" && Number.isFinite(value)\n ? { kind: \"literal\", value, sql: String(value) }\n : undefined;\n case \"boolean\":\n return typeof value === \"boolean\"\n ? { kind: \"literal\", value, sql: value ? \"TRUE\" : \"FALSE\" }\n : undefined;\n case \"date\": {\n const literal = dateDefaultLiteral(value, type);\n return literal === undefined ? undefined : { kind: \"literal\", value: literal, sql: quoteSqlLiteral(literal) };\n }\n case \"map\":\n case \"array\":\n case \"geopoint\": {\n // A document default is a JSON literal cast to the column's own\n // type, so `jsonb` and `json` columns each get a value Postgres\n // accepts without an implicit cast.\n if (type.kind !== \"jsonb\" && type.kind !== \"json\") return undefined;\n let json: string;\n try {\n json = JSON.stringify(value);\n } catch {\n return undefined; // circular, or a BigInt: not a literal.\n }\n if (json === undefined) return undefined;\n return { kind: \"literal\", value, sql: `${quoteSqlLiteral(json)}::${type.kind}` };\n }\n default:\n return undefined;\n }\n};\n\n/**\n * The DEFAULT a column carries: id strategy, then `autoValue`, then a\n * `databaseDefault` given as SQL, then `defaultValue`.\n */\nconst columnDefault = (\n propName: string,\n prop: Property,\n collection: CollectionConfig,\n type: PgType\n): ColumnDefault | undefined => {\n const idDefault = idColumnDefault(propName, prop, collection);\n if (idDefault) {\n if (idDefault.kind === \"uuid\") return { kind: \"sql\", expression: \"gen_random_uuid()\" };\n if (idDefault.kind === \"identity\") return { kind: \"identity\" };\n return { kind: \"sql\", expression: idDefault.expression };\n }\n if (prop.type === \"date\") {\n const autoValue = (prop as DateProperty).autoValue;\n if (autoValue === \"on_create\" || autoValue === \"on_update\") {\n return { kind: \"sql\", expression: \"now()\" };\n }\n }\n if (typeof prop.databaseDefault === \"string\") {\n const expression = sqlExpressionText(prop.databaseDefault).trim();\n if (expression) return { kind: \"sql\", expression };\n }\n return literalDefault(prop, type);\n};\n\n// ── Policies ─────────────────────────────────────────────────────────────────\n\n/**\n * One security rule, compiled to the clauses a policy is made of.\n *\n * The compilation is `compileRulePolicies` in `@rebasepro/common`, which the\n * Studio's RLS editor also compares the live database against — so the UI, the\n * DDL and the database agree about who can read a row. What this adds is only\n * the planner's bookkeeping: which rule a policy came from, and whether Rebase\n * injected it.\n */\nexport const compileSecurityRule = (\n collection: CollectionConfig,\n rule: SecurityRule,\n resolveCollection: ResolveCollection,\n injected: boolean,\n ruleKey = rule.name ?? \"(unnamed)\"\n): PolicyPlan[] => {\n const supersedes = getPolicySupersededNames(rule, getTableName(collection));\n return compileRulePolicies(collection, rule, { resolveCollection })\n .map((policy, index) => ({\n ...policy,\n ruleKey,\n injected,\n ...(index === 0 && supersedes.length > 0 ? { supersedes } : {})\n }));\n};\n\n/**\n * Refuse two of a table's policies that Postgres would store under one name.\n *\n * Each policy is rendered as `DROP POLICY IF EXISTS \"<name>\"` and then its\n * `CREATE`, and Postgres keeps the first 63 bytes of the name, so the second\n * of two policies whose names share those bytes drops the first and takes its\n * place. On a table of 56 bytes or more every unnamed rule of one operation is\n * `<table>_<op>` once stored, so a restrictive gate followed by a grant left\n * the grant alone in force. One rule's own operations never collide here —\n * `getPolicyNamesForRule` names them apart — so a collision is always two\n * rules, and the author names one of them.\n */\nconst sameStoredPolicy = (a: PolicyPlan, b: PolicyPlan): boolean =>\n a.name === b.name && a.operation === b.operation && a.mode === b.mode\n && a.roles.join(\",\") === b.roles.join(\",\") && a.using === b.using && a.withCheck === b.withCheck;\n\nfunction assertDistinctStoredPolicyNames(policies: PolicyPlan[]): void {\n const owners = new Map<string, PolicyPlan>();\n for (const policy of policies) {\n const stored = toPostgresIdentifier(policy.name);\n const first = owners.get(stored);\n if (!first) {\n owners.set(stored, policy);\n continue;\n }\n // The same policy twice — a rule repeated verbatim — replaces itself.\n if (sameStoredPolicy(first, policy)) continue;\n throw new Error(\n `The security rules \"${first.ruleKey}\" and \"${policy.ruleKey}\" compile to the policies ` +\n `\"${first.name}\" and \"${policy.name}\", which Postgres stores under one name, \"${stored}\": it ` +\n \"keeps only the first 63 bytes of an identifier, so the second would replace the first. \" +\n \"Give one of the rules a shorter `name`, or the collection a shorter `table`.\"\n );\n }\n}\n\n/**\n * A table's policies, minus any superseded name Postgres would store one of\n * them under.\n *\n * A superseded name is a 63-byte cut, and another rule's over-long name can\n * cut to the very same bytes — `<table>_default_admin_read` and the old\n * `<table>_default_admin_write_<op>` both do on a 50-byte table. Dropping it\n * then would drop that policy right after its own `CREATE`. Its own `DROP\n * POLICY IF EXISTS` already removes the old policy, so nothing is lost.\n */\nconst withoutLiveSupersededNames = (policies: PolicyPlan[]): PolicyPlan[] => {\n assertDistinctStoredPolicyNames(policies);\n const stored = new Set(policies.map(policy => toPostgresIdentifier(policy.name)));\n return policies.map(policy => {\n if (!policy.supersedes) return policy;\n const supersedes = policy.supersedes.filter(name => !stored.has(name));\n if (supersedes.length === policy.supersedes.length) return policy;\n const kept: PolicyPlan = { ...policy };\n if (supersedes.length > 0) kept.supersedes = supersedes;\n else delete kept.supersedes;\n return kept;\n });\n};\n\n// ── The planner ──────────────────────────────────────────────────────────────\n\nexport function planSchema(allCollections: CollectionConfig[], options: PlanOptions = {}): SchemaPlan {\n // Before the filter, deliberately: a `search` block on a collection this\n // engine does not store would otherwise be dropped without a word.\n assertSearchIsPostgresOnly(allCollections);\n // Same reasoning, and a stronger reason to be loud: a `beforeQuery` that\n // does nothing is a row filter that does nothing.\n assertBeforeQueryIsPostgresOnly(allCollections);\n\n // A Firestore or MongoDB collection has no table here, and generating one\n // is not merely wasted output: `db push` would create it, and the doctor\n // would then report the store the collection actually reads from as drift.\n const collections = relationalCollections(allCollections);\n\n // The first collection, in declaration order, whose slug or table name is\n // the key — what `collections.find(...)` answered, from a map built once\n // rather than a scan per lookup.\n const firstBySlugOrTable = new Map<string, CollectionConfig>();\n for (const c of collections) {\n for (const key of [c.slug, getTableName(c)]) {\n if (!firstBySlugOrTable.has(key)) firstBySlugOrTable.set(key, c);\n }\n }\n const resolveCollection: ResolveCollection = (slug) => firstBySlugOrTable.get(slug);\n\n const declaredSchemas = Array.from(new Set(\n collections.map(c => (isPostgresCollectionConfig(c) ? c.schema : undefined)).filter(Boolean) as string[]\n ));\n const schemas = Array.from(new Set([REBASE_SCHEMA, ...declaredSchemas]));\n\n // ── Enum types ───────────────────────────────────────────────────────────\n // The name is derived from table + column, so two collections mapped onto\n // the same table — or two properties whose `columnName` resolves to the\n // same column — land on the same type. `CREATE TYPE` has no IF NOT EXISTS,\n // so emitting it twice aborts the whole file; deduplicated by name here,\n // once, for every renderer.\n //\n // Deduplicated by the name *Postgres* holds, which is the first 63 bytes,\n // and only for the same column. Two different columns deriving one name —\n // `orders.item_status` and `orders_item.status`, or two long names that\n // share their first 63 bytes — cannot share a type: the second column would\n // be typed with the first one's labels and reject its own. The name is\n // frozen once a database holds it, so this refuses rather than renaming.\n const enums: EnumPlan[] = [];\n const enumOwners = new Map<string, { table: string; column: string; owner: string }>();\n /**\n * Every enum type one table's properties declare, appended once.\n *\n * `declaredSchema` is passed rather than read off the config because a\n * junction's synthetic collection carries `schema: \"public\"` as a resolved\n * fact and not as a declaration — emitting it as one would make the\n * generated file reach for a `pgSchema(\"public\")` variable that exists for\n * nobody.\n */\n const collectEnumTypes = (\n collection: CollectionConfig,\n properties: Properties,\n declaredSchema: string | undefined\n ): void => {\n for (const [propName, rawProp] of Object.entries(properties)) {\n const prop = rawProp as Property;\n if (!(\"enum\" in prop) || !prop.enum) continue;\n if (prop.type !== \"string\" && prop.type !== \"number\") continue;\n // Refuses an empty list whatever the property's type, then declares\n // a type only for the string ones: a `number` enum's column is\n // NUMERIC or INTEGER on every path, so the type used to be created\n // and referenced by nothing.\n const labels = enumLabelsOf(propName, prop, collection);\n if (!declaresEnumType(prop)) continue;\n const schema = schemaOf(collection);\n const table = getTableName(collection);\n const column = resolveColumnName(propName, prop);\n const name = `${table}_${column}`;\n const qualified = `${schema}.${toPostgresIdentifier(name)}`;\n const owner = `property \"${propName}\" of collection \"${describe(collection)}\"`;\n const claimed = enumOwners.get(qualified);\n if (claimed) {\n if (claimed.table === table && claimed.column === column) continue;\n throw new Error(\n `The enum ${owner} and the enum ${claimed.owner} both derive the Postgres type ` +\n `\"${schema}\".\"${toPostgresIdentifier(name)}\" (an enum type is named <table>_<column>, ` +\n \"and Postgres keeps the first 63 bytes). One type cannot hold both columns' values, and a \" +\n \"type's name cannot change once a database holds it. Give one of the two columns another \" +\n \"name with `columnName`, or its collection another `table` or `schema`.\"\n );\n }\n enumOwners.set(qualified, { table, column, owner });\n enums.push({\n schema,\n name,\n qualified,\n declaredSchema,\n varName: getEnumVarName(getTableName(collection), propName),\n labels\n });\n }\n };\n for (const collection of collections) {\n collectEnumTypes(\n collection,\n (collection.properties ?? {}) as Properties,\n isPostgresCollectionConfig(collection) ? collection.schema : undefined\n );\n }\n\n // ── The table set ────────────────────────────────────────────────────────\n // Each collection's table, then any junction its relations imply, in the\n // order the collections arrive. `schema.sql` and `schema.generated.ts` are\n // compared against their committed copies, so this order is the file's.\n const tableEntries = new Map<string, {\n collection: CollectionConfig;\n junction?: { relation: ResolvedRelation; source: CollectionConfig };\n }>();\n const junctionShapes = new Map<string, { keys: string; claim: string }>();\n for (const collection of collections) {\n const tableName = getTableName(collection);\n if (tableName) tableEntries.set(tableName, { collection });\n for (const [relationKey, relation] of Object.entries(resolveCollectionRelations(collection))) {\n if (!isManyToMany(relation)) continue;\n const junctionTable = relation.through.table;\n assertOneJunctionShape(junctionShapes, junctionTable, collection, relation.relationName ?? relationKey, relation);\n if (tableEntries.has(junctionTable)) continue;\n tableEntries.set(junctionTable, {\n collection: { table: junctionTable, properties: {} } as CollectionConfig,\n junction: { relation, source: collection }\n });\n }\n }\n\n const junctionSpecs = resolveJunctionSpecs(collections);\n\n // A junction's payload may declare an enum too, and the type it names is\n // created by nobody else: no collection owns the table, so the loop above\n // never sees the property. Appended after the collections' — the enum block\n // is compared byte-for-byte against its committed copy, and a junction\n // whose type interleaved with the collections' would reorder that file\n // whenever a `through.properties` block moved.\n for (const spec of junctionSpecs.values()) {\n if (Object.keys(spec.properties).length === 0) continue;\n collectEnumTypes(getJunctionCollectionConfig(spec), spec.properties, undefined);\n }\n\n const triggerFunctionNeeded = { value: false };\n\n const tables: TablePlan[] = [];\n for (const [tableName, entry] of tableEntries) {\n tables.push(entry.junction\n ? planJunctionTable(\n tableName, entry.junction.relation, entry.junction.source,\n junctionSpecs, resolveCollection, triggerFunctionNeeded)\n : planCollectionTable(entry.collection, resolveCollection, triggerFunctionNeeded));\n }\n\n assertNoTruncationCollisions(tables, enums);\n\n // ── Extensions and functions ─────────────────────────────────────────────\n const extensions: string[] = [];\n const functions: string[] = [];\n const seenStatements = new Set<string>();\n const add = (into: string[], statement: string): void => {\n if (seenStatements.has(statement)) return;\n seenStatements.add(statement);\n into.push(statement);\n };\n for (const table of tables) {\n if (!table.search) continue;\n for (const statement of searchExtensionStatements(table.search)) add(extensions, statement);\n }\n // pgvector is a separate build behind an image, a grant and a provider\n // allow-list, so whether Rebase may install it is not Rebase's to decide.\n // See `DatabaseOptions.extensions`.\n if (vectorExtensionDeclared(options.databaseExtensions)\n && tables.some(t => t.vectorColumns.length > 0)) {\n add(extensions, vectorExtensionStatement());\n }\n for (const table of tables) {\n if (!table.search) continue;\n for (const statement of searchHelperFunctions(table.search)) add(functions, statement);\n }\n if (triggerFunctionNeeded.value) add(functions, setUpdatedAtFunction());\n\n return {\n schemas,\n declaredSchemas,\n enums,\n tables,\n relations: planRelations(collections, tableEntries),\n extensions,\n functions,\n collections,\n options\n };\n}\n\n/**\n * Refuse two relations — tables, junctions and enum types share one namespace\n * per schema, because every table owns a row type of its own name — that are\n * distinct in full but one name after Postgres keeps the first 63 bytes.\n *\n * `a_table_with_a_really_long_name_that_goes_on_and_on_and_on_forever` with an\n * enum column and a many-to-many truncated its table, its enum type and its\n * junction to the same identifier: the push failed with `type \"…\" already\n * exists` and no validator mentioned the length. A name that already works is\n * never touched — only a collision that cannot be created refuses.\n */\nfunction assertNoTruncationCollisions(tables: TablePlan[], enums: EnumPlan[]): void {\n const owners = new Map<string, string>();\n const claim = (schema: string, name: string, what: string): void => {\n const key = `${schema}.${toPostgresIdentifier(name)}`;\n const first = owners.get(key);\n if (first === undefined) {\n owners.set(key, what);\n return;\n }\n throw new Error(\n `The ${what} and the ${first} both become \"${schema}\".\"${toPostgresIdentifier(name)}\" in Postgres, ` +\n \"which keeps only the first 63 bytes of an identifier — and a table, a junction table and an enum \" +\n \"type share one namespace (every table owns a row type of its name). The push would fail with \" +\n \"\\\"already exists\\\". Give the collection a shorter `table`, or the enum's property a shorter \" +\n \"`columnName` (an enum type is named <table>_<column>).\"\n );\n };\n for (const table of tables) {\n claim(table.schema, table.table, table.kind === \"junction\" ? `junction table \"${table.table}\"` : `table \"${table.table}\"`);\n }\n for (const e of enums) claim(e.schema, e.name, `enum type \"${e.name}\"`);\n}\n\n/**\n * Refuse two many-to-many relations that resolve to one junction table with\n * different key columns.\n *\n * A default `through` is named after the two tables, so `posts.tags` and\n * `posts.featuredTags` both resolve to `posts_tags` — one keyed by `tag_id`,\n * the other by `featured_tag_id`. One table is created, from whichever came\n * first, so the other relation read and wrote a column that was never there.\n * The two sides of one link (`posts.tags` and `tags.posts`) share a junction\n * legitimately, and they name the same two columns — so the comparison is of\n * the (column, endpoint) pairs, in either order.\n */\nfunction assertOneJunctionShape(\n seen: Map<string, { keys: string; claim: string }>,\n junctionTable: string,\n collection: CollectionConfig,\n relationName: string,\n relation: ResolvedRelation\n): void {\n if (!isManyToMany(relation)) return;\n // A target that does not resolve plans no junction here; `resolveJunctionSpecs` skips it the same way.\n const target: CollectionConfig | undefined = relation.target();\n if (!target) return;\n const sourceTable = getTableName(collection);\n const targetTable = getTableName(target);\n const { sourceColumn, targetColumn } = relation.through;\n const keys = JSON.stringify([[sourceColumn, sourceTable], [targetColumn, targetTable]].sort());\n const claim = `the relation \"${relationName}\" of collection \"${describe(collection)}\" ` +\n `(\"${sourceColumn}\" → ${sourceTable}, \"${targetColumn}\" → ${targetTable})`;\n const first = seen.get(junctionTable);\n if (!first) {\n seen.set(junctionTable, { keys, claim });\n return;\n }\n if (first.keys === keys) return;\n throw new Error(\n `Two many-to-many relations resolve to the junction table \"${junctionTable}\" with different key ` +\n `columns: ${first.claim} and ${claim}. Only one table is created, so one of them would read ` +\n \"and write columns that do not exist. Give the second its own junction — \" +\n `\\`through: { table: \"${sourceTable}_${toSnakeCase(relationName)}\" }\\` — or, if both are meant to ` +\n \"be one link, declare it once.\"\n );\n}\n\n// ── A collection's table ─────────────────────────────────────────────────────\n\nfunction planCollectionTable(\n collection: CollectionConfig,\n resolveCollection: ResolveCollection,\n triggerFunctionNeeded: { value: boolean }\n): TablePlan {\n const schema = schemaOf(collection);\n const table = bareTableName(getTableName(collection));\n const auth = isAuthCollection(collection);\n const columns: ColumnPlan[] = [];\n const triggers: TriggerPlan[] = [];\n const relations = resolveCollectionRelations(collection);\n\n for (const [propName, rawProp] of Object.entries(collection.properties ?? {})) {\n const prop = rawProp as Property;\n\n if (prop.type === \"relation\") {\n const column = planRelationColumn(propName, prop as RelationProperty, collection, relations, schema, table);\n if (column) columns.push(column);\n continue;\n }\n if (prop.type === \"reference\") {\n columns.push(planReferenceColumn(propName, prop as ReferenceProperty, collection, resolveCollection, schema, table));\n continue;\n }\n\n columns.push(planPropertyColumn(propName, prop, {\n collection,\n resolveCollection,\n schema,\n table,\n auth,\n triggers,\n triggerFunctionNeeded\n }));\n }\n\n // ── Auth columns the collection file never mentions ──────────────────────\n // `db push` is declarative: Atlas diffs the database against exactly what\n // is emitted and drops anything else. The scaffold's users collection\n // describes 12 columns while auth needs 14, so `is_anonymous` and\n // `tokens_valid_after` read as unmanaged drift and a push run after the\n // server had started once planned to DROP them.\n if (auth) {\n const declared = new Set(columns.map(c => c.column));\n for (const spec of AUTH_USERS_COLUMNS) {\n if (declared.has(spec.column)) continue;\n columns.push({\n key: spec.column,\n column: spec.column,\n type: authColumnType(spec.type),\n nullable: spec.notNull !== true,\n primaryKey: false,\n unique: false,\n sqlDefinition: authUsersColumnSql(spec),\n source: { kind: \"auth\", slug: collection.slug }\n });\n }\n }\n\n // ── The opt-in search column ─────────────────────────────────────────────\n // Last, so it reads as what it is: derived from the columns above it.\n // Postgres recomputes it on every write of a source column and rejects any\n // attempt to write it directly, which is what makes it impossible for the\n // index to drift from the row.\n const search = buildSearchColumnSpec(collection);\n if (search) {\n columns.push({\n key: search.column,\n column: search.column,\n type: { kind: \"tsvector\" },\n nullable: true,\n primaryKey: false,\n unique: false,\n generated: { expression: search.expression, stored: true },\n sqlDefinition: searchColumnTypeSql(search.expression, \"tsvector\"),\n source: { kind: \"search\", slug: collection.slug }\n });\n if (search.fuzzy) {\n columns.push({\n key: search.fuzzy.column,\n column: search.fuzzy.column,\n type: { kind: \"text\" },\n nullable: true,\n primaryKey: false,\n unique: false,\n generated: { expression: search.fuzzy.expression, stored: true },\n sqlDefinition: searchColumnTypeSql(search.fuzzy.expression, \"text\"),\n source: { kind: \"search\", slug: collection.slug }\n });\n }\n }\n\n const primaryKey = planPrimaryKey(collection, columns);\n\n const injected = new Set(getInjectedSecurityRules(collection).map(rule => rule.name));\n const policies = withoutLiveSupersededNames(getEffectiveSecurityRules(collection).flatMap((rule, index) =>\n compileSecurityRule(\n collection,\n rule,\n resolveCollection,\n Boolean(rule.name && injected.has(rule.name)),\n rule.name ?? `#${index}`\n )));\n\n // ── Tenancy ──────────────────────────────────────────────────────────────\n // The policy is already above — `getEffectiveSecurityRules` injects it, so\n // it compiles, names and renders like every other rule. What is left is the\n // half a rule cannot express: the column is NOT NULL, and it is indexed.\n const tenantIndexes = applyTenantColumnEffects(collection, columns, primaryKey, schema, table);\n\n // Last among the columns, because it reads a nullability the two passes\n // above can still change.\n settleDefaultOnDelete(collection, columns, relations);\n\n // After every other index, because the foreign-key ones defer to them: a\n // declared index or the tenant index that already leads with the column\n // serves the same lookups, and a second one would only cost writes.\n const indexes = [...buildCollectionIndexSpecs(collection, resolveColumnName), ...tenantIndexes];\n indexes.push(...planForeignKeyIndexes(schema, table, columns, primaryKey, indexes, column => {\n // A `belongsTo` whose author opted out keeps its constraint and loses\n // only the index. Asked of the relation, not the column: the column a\n // declared property owns carries no relation of its own.\n if (column.source.kind !== \"relation\" || !column.source.propName) return false;\n const prop = collection.properties?.[column.source.propName] as RelationProperty | undefined;\n const relation = findRelation(relations, prop?.relation?.relationName ?? column.source.propName);\n return relation?.kind === \"belongsTo\" && relation.index;\n }));\n\n return {\n schema,\n table,\n qualified: `${schema}.${table}`,\n declaredSchema: isPostgresCollectionConfig(collection) ? collection.schema : undefined,\n varName: getTableVarName(getTableName(collection)),\n kind: \"collection\",\n slug: collection.slug,\n columns,\n primaryKey,\n indexes,\n search,\n vector: buildVectorIndexPlan(collection, resolveColumnName),\n vectorColumns: buildVectorColumnSpecs(collection, resolveColumnName),\n policies,\n triggers,\n auth\n };\n}\n\n/**\n * The table's primary key, as the column names {@link TablePlan.primaryKey}\n * lists — and the columns adjusted to state it one way only.\n *\n * One `isId` property is a key column of its own, declared inline\n * (`\"id\" INTEGER PRIMARY KEY`, `.primaryKey()`), which is how\n * {@link planPropertyColumn} planned it. Several are one composite key, and a\n * composite key cannot be said column by column: two inline `PRIMARY KEY`\n * clauses are two primary keys, which Postgres refuses. So each member stops\n * being a key of its own, keeps NOT NULL (the constraint implies it, and every\n * emitter spells it on the column so the three read the same), and the table\n * gets one `PRIMARY KEY (a, b)` over the list returned here — the shape a\n * junction's key has always had.\n *\n * A collection that declares no key gets an implicit `id TEXT PRIMARY KEY`,\n * which is what `getPrimaryKeys` reads back.\n */\nfunction planPrimaryKey(collection: CollectionConfig, columns: ColumnPlan[]): string[] {\n const keyNames = primaryKeyPropertyNames(collection);\n\n if (keyNames.length > 1) {\n return keyNames.map(name => {\n const column = columns.find(c => c.source.propName === name && !c.columnOwnedByProperty);\n if (!column) {\n throw new Error(\n `Property \"${name}\" of collection \"${describe(collection)}\" is marked \\`isId\\`, and it puts ` +\n \"no column on this table, so it cannot be part of the table's primary key. Mark the \" +\n \"property that holds the column instead.\"\n );\n }\n column.primaryKey = false;\n column.nullable = false;\n return column.column;\n });\n }\n\n // With a default the database fills. Nothing else can: the key is not a\n // property, so the admin form has no field for it, and REST, the SDK and\n // the socket send none. Without one, every insert into a collection that\n // declares no key — the quickstart's first one among them — was refused\n // as a missing `id`. The column stays TEXT so a table created before this\n // keeps its type, and boot's ensure adds the default to it: a DEFAULT binds\n // only future writes, so it is the one change it makes to an existing\n // column. A key the caller does supply still wins over the default.\n if (!columns.some(c => c.primaryKey)) {\n columns.unshift({\n key: \"id\",\n column: \"id\",\n type: { kind: \"text\" },\n nullable: false,\n primaryKey: true,\n unique: false,\n default: { kind: \"sql\", expression: IMPLICIT_ID_DEFAULT },\n source: { kind: \"implicit-id\", slug: collection.slug }\n });\n }\n return columns.filter(c => c.primaryKey).map(c => c.column);\n}\n\n/** What {@link planPropertyColumn} needs about the table the column lands on. */\ninterface PropertyColumnContext {\n /** The collection, or the synthetic one standing in for a junction. */\n collection: CollectionConfig;\n resolveCollection: ResolveCollection;\n schema: string;\n /** Bare table name — the trigger name is derived from it. */\n table: string;\n /** Whether `auth-users-columns` owns this table's columns. */\n auth: boolean;\n /** Collected `BEFORE UPDATE` triggers, appended to. */\n triggers: TriggerPlan[];\n triggerFunctionNeeded: { value: boolean };\n}\n\n/**\n * One declared, non-linking property, as a column.\n *\n * Extracted from {@link planCollectionTable} the moment a second table needed\n * it: a `manyToMany`'s `through.properties` are columns on the junction, and\n * \"declared exactly like a collection's properties\" has to mean the same code\n * reads them, or it is a promise the next `columnType` or `defaultValue` change\n * quietly breaks. A junction payload column therefore gets the type, the\n * nullability, the default, the UNIQUE and the `on_update` trigger a collection\n * column with the same declaration gets — because it is the same function\n * answering.\n *\n * `relation` and `reference` do not come through here; they own a foreign key\n * and are planned by {@link planRelationColumn} / {@link planReferenceColumn}.\n * A junction payload may not declare either (config validation refuses it), so\n * this is the whole of a payload column.\n */\nfunction planPropertyColumn(\n propName: string,\n prop: Property,\n ctx: PropertyColumnContext\n): ColumnPlan {\n const { collection, resolveCollection, schema, table, auth } = ctx;\n\n const isId = isIdProperty(propName, prop, collection);\n const column = resolveColumnName(propName, prop);\n const type = columnPgType(propName, prop, collection, resolveCollection);\n const required = prop.validation?.required === true;\n const defaultValue = columnDefault(propName, prop, collection, type);\n // On an auth collection, the columns auth itself reads and writes have\n // exactly one definition wherever the table is created from — see\n // `auth-users-columns`. Anything else there is an ordinary field.\n const authDefinition = auth && !isId ? authUsersColumnDefinition(column) : undefined;\n\n const plan: ColumnPlan = {\n key: propName,\n column,\n type,\n // A primary key is NOT NULL whether or not anyone writes it.\n nullable: !(isId || required),\n primaryKey: isId,\n // `validation.unique` holds for every type. The Drizzle generator\n // honoured it on `string` and `number` only, so a unique `date` or\n // `map` was UNIQUE in the database and not in the file drizzle-kit\n // plans from. A primary key gets neither UNIQUE nor NOT NULL —\n // both are implied, and emitting them made drizzle-kit plan an\n // extra constraint against a database `db push` built without one.\n unique: !isId && prop.validation?.unique === true,\n default: defaultValue,\n sqlDefinition: authDefinition,\n source: { kind: \"property\", propName, slug: collection.slug }\n };\n if (prop.type === \"date\" && (prop as DateProperty).autoValue === \"on_update\") {\n plan.touchOnUpdate = true;\n ctx.triggerFunctionNeeded.value = true;\n ctx.triggers.push({\n schema,\n table,\n column,\n name: toPostgresIdentifier(`${table}_${column}_touch`)\n });\n }\n return plan;\n}\n\n/**\n * The two schema effects a `tenant` declaration has that a policy cannot state.\n *\n * The policy itself is injected as an ordinary `SecurityRule`\n * (`buildTenantSecurityRule`) and compiled above with every other rule, so\n * nothing here touches `policies`. What is left is the column:\n *\n * - **`NOT NULL`.** A row whose tenant is NULL belongs to nobody, and the\n * restrictive policy compares the column to the caller's tenant — a\n * comparison against NULL is never true. Such a row is therefore invisible to\n * every caller, forever, including the one who wrote it. The write path\n * refuses to create one (`TENANT_REQUIRED`); this is the same statement made\n * where a raw `INSERT`, a seed and a migration can also hear it.\n * - **An index.** The tenancy predicate is ANDed into *every* statement against\n * the table, so an unindexed tenant column turns every read into a sequential\n * scan filtered by tenant. It is the one index a tenant-scoped table cannot\n * be without, and the one people most reliably forget — which is the whole\n * argument for deriving it rather than documenting it.\n *\n * The index goes through `deriveIndexName` like every other index, so it is a\n * Rebase-managed name (`_ix_<fingerprint>`), it is in the Atlas diff, and the\n * doctor recognises it. Because that name is a fingerprint of the index's\n * semantics, an author who has *already* declared a plain btree index on the\n * tenant column derives byte-for-byte the same name — so the two are the same\n * object and this adds nothing rather than colliding.\n *\n * Throws when the field names no column. `planSchema` throws rather than\n * guessing, and the alternative here is a table with a tenancy policy over a\n * column that does not exist: `CREATE POLICY` fails, RLS stays enabled, and the\n * collection denies every row.\n */\nfunction applyTenantColumnEffects(\n collection: CollectionConfig,\n columns: ColumnPlan[],\n primaryKey: string[],\n schema: string,\n table: string\n): CollectionIndexSpec[] {\n const tenant = getTenantConfig(collection);\n if (!tenant) return [];\n\n const column = findTenantColumn(collection, columns, tenant.field);\n if (!column) {\n throw new Error(\n `Collection \"${describe(collection)}\" declares \\`tenant: { field: \"${tenant.field}\" }\\`, and ` +\n \"no property of that name reaches a column. `tenant` says what a column means; it does not \" +\n \"create one. Declare the property, or name the one that holds the tenant id.\"\n );\n }\n\n // The leading column of the primary key is already NOT NULL and already\n // indexed by `<table>_pkey`. Saying either again would make `db push` plan\n // a constraint and an index the database has no reason to hold. A later\n // column of a composite key is NOT NULL too, but `<table>_pkey` cannot\n // serve a lookup on it alone, so it still gets its index.\n if (primaryKey[0] === column.column) return [];\n\n column.nullable = false;\n\n const withoutName = {\n schema,\n table,\n method: \"btree\" as const,\n unique: false,\n keys: [{ column: column.column, direction: \"asc\" as const, nulls: \"last\" as const }],\n include: [],\n predicate: null,\n reason: TENANT_INDEX_REASON\n };\n return [{ ...withoutName, indexName: deriveIndexName(withoutName) }];\n}\n\n/**\n * A btree on each foreign-key column of one table, where nothing already\n * serves the lookup — see `foreignKeyIndexSpec` for why the column needs one.\n *\n * Skipped, so that no table ever carries two indexes doing one job, when the\n * column already leads:\n *\n * - the primary key — `<table>_pkey` is a btree over the key in key order, so\n * its first column is indexed and the rest are not (a junction's\n * `(post_id, tag_id)` key serves `post_id`, and `tag_id` gets an index);\n * - a UNIQUE on the column (`validation.unique`, on the relation or on the\n * property that owns the column) — Postgres backs it with a btree;\n * - another planned index that leads with it ({@link leadsWithColumn}) — one\n * the collection declares in `indexes:`, or the tenant index.\n *\n * Only the plan is consulted, never the catalogue: `db push` renders this from\n * the collections alone, and boot has to reach the same set with the same\n * names, or Atlas would plan to drop what boot built.\n */\nfunction planForeignKeyIndexes(\n schema: string,\n table: string,\n columns: ColumnPlan[],\n primaryKey: string[],\n planned: readonly CollectionIndexSpec[],\n wantsIndex: (column: ColumnPlan) => boolean\n): CollectionIndexSpec[] {\n const created = columns.filter(c => !c.columnOwnedByProperty);\n const derived: CollectionIndexSpec[] = [];\n for (const column of columns) {\n const fk = column.foreignKey;\n if (!fk || !wantsIndex(column)) continue;\n const name = fk.column;\n if (primaryKey[0] === name) continue;\n if (created.some(c => c.column === name && c.unique)) continue;\n if ([...planned, ...derived].some(spec => leadsWithColumn(spec, name))) continue;\n derived.push(foreignKeyIndexSpec(schema, table, name));\n }\n return derived;\n}\n\n/**\n * The planned column a `tenant.field` names.\n *\n * Not simply `columns.find(c => c.key === field)`: a `belongsTo` relation\n * property emits its column under the *foreign key's* field name, so\n * `tenant: { field: \"org\" }` beside `org: { type: \"relation\", … }` has to\n * resolve through the relation to `org_id`. Matching only on `key` found\n * nothing there and the declaration would have been refused as naming no\n * column — for the shape the documentation recommends.\n */\nfunction findTenantColumn(\n collection: CollectionConfig,\n columns: ColumnPlan[],\n field: string\n): ColumnPlan | undefined {\n // Only columns that are created. A relation whose column a declared\n // property owns keeps an entry for its constraint alone, under the same key\n // and column; when the relation was declared first, NOT NULL landed on that\n // entry, nothing rendered it, and the tenant column stayed nullable.\n const created = columns.filter(c => !c.columnOwnedByProperty);\n const direct = created.find(c => c.key === field);\n if (direct) return direct;\n\n const prop = collection.properties?.[field] as Property | undefined;\n if (prop?.type === \"relation\") {\n const relations = resolveCollectionRelations(collection);\n const relation = findRelation(relations, (prop as RelationProperty).relation?.relationName ?? field);\n if (relation?.kind === \"belongsTo\" && relation.localKey) {\n return created.find(c => c.column === relation.localKey);\n }\n return undefined;\n }\n if (!prop) return undefined;\n const columnName = resolveColumnName(field, prop);\n return created.find(c => c.column === columnName);\n}\n\n/**\n * The `ON DELETE` a link gets when the author did not say, decided from the\n * column as it will be created.\n *\n * {@link planRelationColumn} and {@link planReferenceColumn} see only their own\n * property's `required`, and two later facts change the premise: `tenant` makes\n * its column NOT NULL, and a declared property that owns a relation's column\n * decides that column's nullability itself. Defaulting before either produced\n * `NOT NULL … ON DELETE SET NULL` — a parent's delete that can only fail, and\n * fails with 23502 naming the child's column rather than as the foreign-key\n * refusal it is. An `onDelete` the author wrote is theirs and is kept.\n */\nfunction settleDefaultOnDelete(\n collection: CollectionConfig,\n columns: ColumnPlan[],\n relations: Record<string, ResolvedRelation>\n): void {\n for (const column of columns) {\n const fk = column.foreignKey;\n if (!fk || declaresOnDelete(collection, relations, column)) continue;\n const created = columns.find(c => c.column === column.column && !c.columnOwnedByProperty) ?? column;\n const onDelete = defaultBelongsToOnDelete(!created.nullable);\n if (onDelete === fk.onDelete) continue;\n column.foreignKey = foreignKeyPlan({\n schema: fk.schema,\n table: fk.table,\n column: fk.column,\n targetSchema: fk.targetSchema,\n targetTable: fk.targetTable,\n targetColumn: fk.targetColumn,\n onDelete,\n onUpdate: fk.onUpdate\n });\n }\n}\n\n/** Whether the author wrote this link's `onDelete`. A `reference` has none to write. */\nconst declaresOnDelete = (\n collection: CollectionConfig,\n relations: Record<string, ResolvedRelation>,\n column: ColumnPlan\n): boolean => {\n const propName = column.source.propName;\n if (column.source.kind !== \"relation\" || !propName) return false;\n const prop = collection.properties?.[propName] as RelationProperty | undefined;\n const relation = findRelation(relations, prop?.relation?.relationName ?? propName);\n return relation?.kind === \"belongsTo\" && relation.onDelete !== undefined;\n};\n\n/**\n * The column a `belongsTo` relation owns, or `undefined` when the relation puts\n * no column on this table.\n *\n * Every other kind is a column on the target, a junction row, or a join chain.\n */\nfunction planRelationColumn(\n propName: string,\n prop: RelationProperty,\n collection: CollectionConfig,\n relations: Record<string, ResolvedRelation>,\n schema: string,\n table: string\n): ColumnPlan | undefined {\n const relation = findRelation(relations, prop.relation?.relationName ?? propName);\n if (relation?.kind !== \"belongsTo\") return undefined;\n\n let target: CollectionConfig;\n try {\n target = relation.target();\n } catch {\n // A relation whose target is not in this bundle yields no column and no\n // constraint. Every emitter returned early here, and they must keep\n // agreeing: a column with no constraint down one path is a schema fork.\n return undefined;\n }\n if (!target) return undefined;\n\n const required = prop.validation?.required === true;\n // The relation and an explicit FK property can both be declared; the\n // explicit one owns the column, and the relation still owns the constraint.\n // Asked of the *field key* rather than the column — `properties[\"post_id\"]`\n // is not where a property declared `postId: { columnName: \"post_id\" }`\n // lives, so this used to emit the column twice and `CREATE TABLE` failed\n // with \"column specified more than once\".\n const fkFieldKey = fieldKeyForColumn(collection, relation.localKey);\n const columnOwnedByProperty = Boolean(collection.properties?.[fkFieldKey]) && propName !== fkFieldKey;\n\n // Only a *derived* column name can be affected by the change to\n // `generateForeignKeyName`; one the author wrote is theirs.\n const relationName = prop.relation?.relationName ?? propName;\n const legacyKey = legacyForeignKeyName(relationName);\n const derived = relation.localKey === generateForeignKeyName(relationName);\n const via = linkLabel(\"relation\", collection, propName);\n\n return {\n key: fkFieldKey,\n column: relation.localKey,\n type: primaryKeyPgType(target, via),\n nullable: !required,\n primaryKey: false,\n // `validation.unique` on a link is a one-to-one, and all three emitters\n // dropped it: the property said unique, the column was not, and a\n // second row could point at the same parent.\n unique: prop.validation?.unique === true,\n columnOwnedByProperty: columnOwnedByProperty || undefined,\n legacyColumn: derived && legacyKey !== relation.localKey ? legacyKey : undefined,\n foreignKey: foreignKeyPlan({\n schema,\n table,\n column: relation.localKey,\n targetSchema: schemaOf(target),\n targetTable: bareTableName(getTableName(target)),\n targetColumn: getPrimaryKeyColumn(target, via),\n onDelete: relation.onDelete ?? defaultBelongsToOnDelete(required),\n onUpdate: relation.onUpdate\n }),\n source: { kind: \"relation\", propName, slug: collection.slug }\n };\n}\n\n/** The column a `reference` property owns — a foreign key like any other. */\nfunction planReferenceColumn(\n propName: string,\n prop: ReferenceProperty,\n collection: CollectionConfig,\n resolveCollection: ResolveCollection,\n schema: string,\n table: string\n): ColumnPlan {\n // A `reference` with no `path` names no collection, so it keeps its column\n // (the id is still a string) and gets no constraint — the same shape as one\n // whose target is not in this bundle.\n const target = prop.path ? resolveCollection(prop.path) : undefined;\n const column = resolveColumnName(propName, prop as Property);\n const required = prop.validation?.required === true;\n const via = linkLabel(\"reference\", collection, propName);\n\n return {\n key: propName,\n column,\n // A `reference` whose target is not in the bundle keeps its column (the\n // id is still a string) and gets no constraint.\n type: target ? primaryKeyPgType(target, via) : { kind: \"text\" },\n nullable: !required,\n primaryKey: false,\n unique: prop.validation?.unique === true,\n foreignKey: target\n ? foreignKeyPlan({\n schema,\n table,\n column,\n targetSchema: schemaOf(target),\n targetTable: bareTableName(getTableName(target)),\n targetColumn: getPrimaryKeyColumn(target, via),\n // The same rule as `belongsTo`, from the same function. A\n // `reference` carries no `onDelete` of its own to override it.\n onDelete: defaultBelongsToOnDelete(required)\n })\n : undefined,\n source: { kind: \"reference\", propName, slug: collection.slug }\n };\n}\n\n/**\n * An auth-owned column's declared SQL type, as a tag.\n *\n * `auth-users-columns` states these as SQL because that is the grammar its three\n * creators write in; the plan needs the tag so nothing downstream has to parse a\n * type back apart. Deliberately exhaustive rather than a fallback: a column auth\n * adds with a type nobody mapped should say so here, not turn into `TEXT` in a\n * table the login flow reads.\n */\nconst AUTH_COLUMN_TYPES: Record<string, PgType> = {\n \"TEXT\": { kind: \"text\" },\n \"TEXT[]\": { kind: \"array\", of: { kind: \"text\" } },\n \"BOOLEAN\": { kind: \"boolean\" },\n \"JSONB\": { kind: \"jsonb\" },\n \"TIMESTAMP WITH TIME ZONE\": { kind: \"timestamptz\" }\n};\n\nconst authColumnType = (sqlType: string): PgType => {\n const mapped = AUTH_COLUMN_TYPES[sqlType];\n if (!mapped) {\n throw new Error(\n `\\`auth-users-columns\\` declares a column of type \"${sqlType}\", which the schema plan ` +\n \"has no tag for. Add it to `AUTH_COLUMN_TYPES` in schema/plan/plan-schema.ts.\"\n );\n }\n return mapped;\n};\n\n// ── A junction table ─────────────────────────────────────────────────────────\n\n/**\n * Which declaring side a junction is planned from.\n *\n * With one side, that side — as it always was, so a junction only one end\n * declares keeps the key every database already has. With both ends declaring\n * it, the planner used to take whichever it reached first, and the two doors\n * reach them in different orders: `db push` loads files by name, boot walks the\n * bundle's array. The same junction was keyed `(a_id, b_id)` by one and\n * `(b_id, a_id)` by the other, and a push against a boot-built database rebuilt\n * the key. Now the side whose table sorts first, which is the order `db push`\n * already used wherever a file is named after its table.\n */\nfunction canonicalJunctionSide(\n table: string,\n relation: ResolvedRelation,\n source: CollectionConfig,\n spec: JunctionSpec | undefined\n): { relation: ResolvedRelation; source: CollectionConfig } {\n if (!spec || spec.declaringSides.length < 2) return { relation, source };\n const ordered = [...spec.declaringSides].sort((a, b) => {\n const left = bareTableName(getTableName(a.collection));\n const right = bareTableName(getTableName(b.collection));\n if (left !== right) return left < right ? -1 : 1;\n return a.junctionColumn < b.junctionColumn ? -1 : a.junctionColumn > b.junctionColumn ? 1 : 0;\n });\n const chosen = ordered[0].collection;\n if (chosen === source) return { relation, source };\n const resolved = Object.values(resolveCollectionRelations(chosen))\n .find(r => isManyToMany(r) && bareTableName(r.through.table) === table);\n return resolved ? { relation: resolved, source: chosen } : { relation, source };\n}\n\nfunction planJunctionTable(\n tableName: string,\n reachedRelation: ResolvedRelation,\n reachedSource: CollectionConfig,\n junctionSpecs: ReturnType<typeof resolveJunctionSpecs>,\n resolveCollection: ResolveCollection,\n triggerFunctionNeeded: { value: boolean }\n): TablePlan {\n const { relation, source } = canonicalJunctionSide(\n bareTableName(tableName), reachedRelation, reachedSource, junctionSpecs.get(bareTableName(tableName)));\n if (!isManyToMany(relation)) {\n throw new Error(`Internal: junction table \"${tableName}\" was reached from a ${relation.kind} relation.`);\n }\n const table = bareTableName(tableName);\n // Junctions live in `public`, full stop — `resolveJunctionSpecs` hardcodes\n // that, so it is where the tables are created and where the derived RLS\n // policies are applied. Inheriting the endpoint's schema put the junction\n // of any m2m onto `users` in `rebase` while its policies were still created\n // against `public.<junction>`: RLS enabled on one table, rows in another.\n const schema = \"public\";\n const target = relation.target();\n const { sourceColumn, targetColumn } = relation.through;\n // Every declaring side agrees on the edge's lifetime; the first one wins.\n const onDelete = relation.onDelete ?? \"CASCADE\";\n\n const spec = junctionSpecs.get(table);\n const legacyFor = (collection: CollectionConfig, column: string): string | undefined => {\n // A junction column's default name is derived from the endpoint\n // collection's slug — normally plural, so this is where the\n // singularization change lands: a `categories` endpoint used to give\n // `categorie_id` and now gives `category_id`. Recorded, not used.\n const slug = toSnakeCase(collection.slug ?? collection.name ?? \"\");\n const legacy = legacyForeignKeyName(slug);\n return column === generateForeignKeyName(slug) && legacy !== column ? legacy : undefined;\n };\n\n const via = linkLabel(\"relation\", source, relation.relationName);\n const endpoint = (collection: CollectionConfig, column: string): ColumnPlan => ({\n key: column,\n column,\n type: primaryKeyPgType(collection, via),\n nullable: false,\n // Part of the composite key on {@link TablePlan.primaryKey}, not a\n // key of its own — an inline `PRIMARY KEY` here would be a second one.\n primaryKey: false,\n unique: false,\n legacyColumn: legacyFor(collection, column),\n foreignKey: foreignKeyPlan({\n schema,\n table,\n column,\n targetSchema: schemaOf(collection),\n targetTable: bareTableName(getTableName(collection)),\n targetColumn: getPrimaryKeyColumn(collection, via),\n onDelete\n }),\n source: { kind: \"junction-key\" }\n });\n\n const columns = [endpoint(source, sourceColumn), endpoint(target, targetColumn)];\n\n // ── The junction's own columns ───────────────────────────────────────────\n // `through.properties`: the `role` on a membership, the `position` on a\n // tag. Planned by the same {@link planPropertyColumn} the collection tables\n // use, against the synthetic collection {@link getJunctionCollectionConfig}\n // builds — so a payload property gets exactly the type, nullability,\n // default, UNIQUE and enum type it would get on a table, and there is no\n // second `switch (prop.type)` anywhere to disagree with the first.\n //\n // Not supported here, and deliberately: `indexes` (declared per collection,\n // and no collection declares a junction), `search`, `vector`, and any\n // linking property — a payload cannot be a `relation`, a `reference` or a\n // `vector`. Config validation refuses those with the relation named; this\n // would otherwise reach `columnPgType` and produce a column no writer knows\n // how to fill.\n const triggers: TriggerPlan[] = [];\n if (spec && Object.keys(spec.properties).length > 0) {\n const junctionCollection = getJunctionCollectionConfig(spec);\n const keyColumns = new Set([sourceColumn, targetColumn]);\n for (const [propName, rawProp] of Object.entries(spec.properties)) {\n const prop = rawProp as Property;\n const plan = planPropertyColumn(propName, prop, {\n collection: junctionCollection,\n resolveCollection,\n schema,\n table,\n auth: false,\n triggers,\n triggerFunctionNeeded\n });\n // A payload column that resolves onto a key column would be a\n // second definition of it — refused by `checkJunctionPayload` at\n // boot, and skipped here so a config that got past it still\n // produces a table rather than a duplicate-column CREATE.\n if (keyColumns.has(plan.column)) continue;\n columns.push(plan);\n }\n }\n\n // Junction tables are generated tables like any other: locked by default,\n // with derived policies — reads follow the endpoints' visibility, writes\n // follow the declaring side's update rules. Without them they were the one\n // kind of generated table with no RLS at all.\n const policies = spec\n ? withoutLiveSupersededNames(getJunctionSecurityRules(spec).flatMap((rule, index) =>\n compileSecurityRule(\n getJunctionCollectionConfig(spec), rule, resolveCollection, false, rule.name ?? `#${index}`)))\n : [];\n\n return {\n schema,\n table,\n qualified: `${schema}.${table}`,\n varName: getTableVarName(tableName),\n kind: \"junction\",\n declaringSlugs: spec?.declaringSides.map(side => side.collection.slug) ?? [],\n columns,\n primaryKey: [sourceColumn, targetColumn],\n // Always, and with no opt-out: the junction is the platform's table,\n // not the author's. The key covers lookups by `sourceColumn`; the\n // reverse side of the link — `tags → posts` — filters on\n // `targetColumn`, which only this index serves.\n indexes: planForeignKeyIndexes(schema, table, columns, [sourceColumn, targetColumn], [],\n column => column.source.kind === \"junction-key\"),\n vectorColumns: [],\n policies,\n triggers,\n auth: false\n };\n}\n\n// ── Drizzle relations ────────────────────────────────────────────────────────\n\n/**\n * The `relations(...)` entries the generated file carries.\n *\n * Both sides of a link must share a `relationName` or Drizzle cannot pair them;\n * `sharedRelationName` is the rule, and each side derives it independently.\n */\nfunction planRelations(\n collections: CollectionConfig[],\n tableEntries: Map<string, { collection: CollectionConfig; junction?: { relation: ResolvedRelation; source: CollectionConfig } }>\n): RelationPlan[] {\n const plans: RelationPlan[] = [];\n\n // Every relation whose foreign key lives on its target's table, grouped by\n // that target's slug, in the order the scan below used to meet them —\n // collections in declaration order, each one's relations in order. Built\n // once: the scan ran once per collection over every other collection's\n // relations, N² in the collection count (24 ms at 200, 204 ms at 1,000).\n const fkOnTargetBySlug = new Map<string, Array<{ other: CollectionConfig; otherRel: ResolvedForeignKeyOnTarget }>>();\n for (const other of collections) {\n for (const otherRel of Object.values(resolveCollectionRelations(other))) {\n if (!hasForeignKeyOnTarget(otherRel)) continue;\n let otherTarget: CollectionConfig;\n try {\n otherTarget = otherRel.target();\n } catch {\n continue;\n }\n const list = fkOnTargetBySlug.get(otherTarget.slug) ?? [];\n list.push({ other, otherRel });\n fkOnTargetBySlug.set(otherTarget.slug, list);\n }\n }\n\n for (const [tableName, entry] of tableEntries) {\n const tableVar = getTableVarName(tableName);\n\n if (entry.junction) {\n const { relation, source } = entry.junction;\n if (!isManyToMany(relation)) continue;\n const target = relation.target();\n const via = linkLabel(\"relation\", source, relation.relationName);\n // Each `one()` here pairs with a `many(junction, { relationName })`\n // on its endpoint, so each takes the name that endpoint's own\n // relation derives — the rule `addJunctionSides` in\n // `config-relations.ts` builds the runtime's relations by.\n //\n // The far side is looked up as the target's many-to-many through\n // this same junction. It used to be matched on the *owning* side's\n // name, which `tags.posts` never carries, so the synthesized name\n // won and `tags`' `many(…, { relationName: \"posts\" })` had nothing\n // to pair with: `with: { posts: true }` threw. Only a junction\n // nothing points back through needs the synthesized name.\n const owningRelationName = sharedRelationName(relation, source);\n let inverse: ResolvedRelation | undefined;\n try {\n inverse = Object.values(resolveCollectionRelations(target)).find(r =>\n r.kind === \"manyToMany\" && bareTableName(r.through.table) === bareTableName(tableName));\n } catch {\n // A target whose relations cannot be resolved declares no inverse.\n }\n const inverseRelationName = inverse\n ? sharedRelationName(inverse, target)\n : `${tableName}_${relation.through.targetColumn}`;\n plans.push({\n tableVar,\n key: relation.through.sourceColumn,\n kind: \"one\",\n targetVar: getTableVarName(getTableName(source)),\n relationName: owningRelationName,\n fields: [relation.through.sourceColumn],\n references: [getPrimaryKeyName(source, via)]\n });\n // A self-referencing link is its own inverse: one name, one\n // endpoint table, and drizzle refuses two relations named alike.\n if (inverseRelationName === owningRelationName) continue;\n plans.push({\n tableVar,\n key: relation.through.targetColumn,\n kind: \"one\",\n targetVar: getTableVarName(getTableName(target)),\n relationName: inverseRelationName,\n fields: [relation.through.targetColumn],\n references: [getPrimaryKeyName(target, via)]\n });\n continue;\n }\n\n const collection = entry.collection;\n // `resolveCollectionRelations` already deduplicates, but an alias entry\n // for the same foreign key would otherwise emit twice.\n const emitted = new Set<string>();\n for (const [key, relation] of Object.entries(resolveCollectionRelations(collection))) {\n let target: CollectionConfig;\n try {\n target = relation.target();\n } catch {\n // A link to a collection outside this bundle is not a relation\n // this file can describe.\n continue;\n }\n const targetVar = getTableVarName(getTableName(target));\n const relationName = sharedRelationName(relation, collection);\n const dedupe = `${relationName}::${relation.kind}`;\n if (emitted.has(dedupe)) continue;\n emitted.add(dedupe);\n\n switch (relation.kind) {\n case \"belongsTo\":\n plans.push({\n tableVar,\n key,\n kind: \"one\",\n targetVar,\n relationName,\n // `localKey` is a COLUMN and the generated object is\n // keyed by PROPERTY: `user_id` is exposed as `userId`,\n // and emitting the column produces a file that does not\n // compile.\n fields: [fieldKeyForColumn(collection, relation.localKey)],\n references: [getPrimaryKeyName(target, linkLabel(\"relation\", collection, key))]\n });\n break;\n case \"hasOne\":\n // The foreign key lives on the TARGET table, so this side\n // states the join from its own end: its source key against\n // the target's foreign key, under the owning side's name.\n // Drizzle has no `one()` paired by `relationName` alone:\n // `one(target, { relationName })` is not a `RelationConfig`\n // (TS2345) and `createOne` reads `config.fields.reduce(...)`.\n // A bare `one(target)` is paired by table, which throws once\n // the target has two links back here or the link is to its\n // own table.\n plans.push({\n tableVar,\n key,\n kind: \"one\",\n targetVar,\n relationName,\n fields: [relation.sourceKey\n ? fieldKeyForColumn(collection, relation.sourceKey)\n : getPrimaryKeyName(collection, linkLabel(\"relation\", collection, key))],\n references: [fieldKeyForColumn(target, relation.foreignKeyOnTarget)],\n nullable: true\n });\n break;\n case \"hasMany\":\n plans.push({ tableVar, key, kind: \"many\", targetVar, relationName });\n break;\n case \"manyToMany\":\n plans.push({\n tableVar,\n key,\n kind: \"many\",\n targetVar: getTableVarName(relation.through.table),\n relationName\n });\n break;\n case \"via\":\n // A join chain is resolved at query time, not modelled as a\n // Drizzle relation.\n break;\n }\n }\n\n // Reciprocals the far side declares and this one does not. Drizzle\n // needs both halves of a pair to exist for a relational query to work.\n for (const { other, otherRel } of fkOnTargetBySlug.get(collection.slug) ?? []) {\n if (other.slug === collection.slug) continue;\n const relationName = sharedRelationName(otherRel, other);\n const dedupe = `${relationName}::belongsTo`;\n if (emitted.has(dedupe)) continue;\n emitted.add(dedupe);\n const otherVar = getTableVarName(getTableName(other));\n const fieldKey = fieldKeyForColumn(collection, otherRel.foreignKeyOnTarget);\n plans.push({\n tableVar,\n key: `_synth_${otherVar}_${fieldKey}`,\n kind: \"one\",\n targetVar: otherVar,\n relationName,\n fields: [fieldKey],\n // The column the far side points at: its primary key,\n // unless the link names another one with `sourceKey`.\n references: [otherRel.sourceKey\n ? fieldKeyForColumn(other, otherRel.sourceKey)\n : getPrimaryKeyName(other, linkLabel(\"relation\", other, otherRel.relationName))]\n });\n }\n }\n\n return plans;\n}\n\nexport { SET_UPDATED_AT_FN };\n"],"mappings":"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"}
@@ -1,8 +1,9 @@
1
1
  import { createRequire as __createRequire } from "module";
2
2
  __createRequire(import.meta.url);
3
3
  import { i as __exportAll } from "./cli-prompt-DXG0yk-h.js";
4
- import { n as generatePostgresPoliciesDdl } from "./generate-postgres-ddl-logic-CogQBrzs.js";
4
+ import { n as generatePostgresPoliciesDdl } from "./generate-postgres-ddl-logic-0rbAqwYT.js";
5
5
  import { RLS_UID_SQL } from "@rebasepro/types";
6
+ import { toPostgresIdentifier } from "@rebasepro/utils";
6
7
  //#region src/security/policy-drift.ts
7
8
  /**
8
9
  * Compare the RLS policies a database actually has against the ones the
@@ -69,7 +70,15 @@ function normalizeMode(raw) {
69
70
  if (upper === "PERMISSIVE" || upper === "TRUE" || upper === "T") return "PERMISSIVE";
70
71
  if (upper === "RESTRICTIVE" || upper === "FALSE" || upper === "F") return "RESTRICTIVE";
71
72
  }
72
- /** Parse the generated DDL rather than rebuilding the shape by hand. */
73
+ /**
74
+ * Parse the generated DDL rather than rebuilding the shape by hand.
75
+ *
76
+ * Each name is the one Postgres stores — its first 63 bytes — because that is
77
+ * the name every live policy is compared under. A rule's name can be longer,
78
+ * and read as written its policy was both "missing" and, once cut to a name of
79
+ * the generated shape, an "orphan" the push's reconcile dropped right after
80
+ * `policies.sql` created it.
81
+ */
73
82
  function parseExpectedPolicies(ddl) {
74
83
  const found = [];
75
84
  for (const m of ddl.matchAll(CREATE_POLICY)) {
@@ -80,7 +89,7 @@ function parseExpectedPolicies(ddl) {
80
89
  found.push({
81
90
  schema,
82
91
  table,
83
- name,
92
+ name: toPostgresIdentifier(name),
84
93
  roles,
85
94
  command: command.toUpperCase(),
86
95
  hasUsing,
@@ -341,4 +350,4 @@ function formatPolicyDrift(drift) {
341
350
  //#endregion
342
351
  export { parseExpectedPolicies as a, isGeneratedPolicyName as i, formatPolicyDrift as n, partitionOrphans as o, hasDrift as r, policy_drift_exports as s, checkPolicyDrift as t };
343
352
 
344
- //# sourceMappingURL=policy-drift-Dqp_yFeE.js.map
353
+ //# sourceMappingURL=policy-drift-0Cp4Lc0x.js.map