@rebasepro/server-postgres 0.28.1 → 0.29.0-canary.g0e3a0e7
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.
- package/dist/PostgresBackendDriver.d.ts +69 -1
- package/dist/PostgresBootstrapper.d.ts +34 -1
- package/dist/{cli-console-C0FYkICX.js → cli-console-CJLtH58M.js} +3 -3
- package/dist/{cli-console-C0FYkICX.js.map → cli-console-CJLtH58M.js.map} +1 -1
- package/dist/cli.js +12 -12
- package/dist/{connection-czvI7TZL.js → connection-CcYqncW5.js} +113 -36
- package/dist/connection-CcYqncW5.js.map +1 -0
- package/dist/connection.d.ts +57 -0
- package/dist/database-health.d.ts +23 -0
- package/dist/{databasePoolManager-BjoVvuAq.js → databasePoolManager-XmhMczz0.js} +2 -2
- package/dist/{databasePoolManager-BjoVvuAq.js.map → databasePoolManager-XmhMczz0.js.map} +1 -1
- package/dist/{deferred-index-build-BcJ_oulu.js → deferred-index-build-BwH6k1Og.js} +30 -1
- package/dist/{deferred-index-build-BcJ_oulu.js.map → deferred-index-build-BwH6k1Og.js.map} +1 -1
- package/dist/{ensure-collection-policies-BNwSQfVx.js → ensure-collection-policies-f0LIwiwp.js} +3 -3
- package/dist/{ensure-collection-policies-BNwSQfVx.js.map → ensure-collection-policies-f0LIwiwp.js.map} +1 -1
- package/dist/{ensure-collection-tables-CSbgkTBx.js → ensure-collection-tables-DvaCEy6X.js} +4 -4
- package/dist/{ensure-collection-tables-CSbgkTBx.js.map → ensure-collection-tables-DvaCEy6X.js.map} +1 -1
- package/dist/{enum-labels-kept-BCgFGAbJ.js → enum-labels-kept-DAbJ_IIl.js} +2 -2
- package/dist/{enum-labels-kept-BCgFGAbJ.js.map → enum-labels-kept-DAbJ_IIl.js.map} +1 -1
- package/dist/index.d.ts +5 -2
- package/dist/index.es.js +4 -4
- package/dist/{migrate-policy-stamps-B-8vTSIm.js → migrate-policy-stamps-CdljD_y1.js} +4 -4
- package/dist/{migrate-policy-stamps-B-8vTSIm.js.map → migrate-policy-stamps-CdljD_y1.js.map} +1 -1
- package/dist/{open-rebase-D9n8idex.js → open-rebase-DvmKIu7q.js} +591 -37
- package/dist/open-rebase-DvmKIu7q.js.map +1 -0
- package/dist/pooled-database.d.ts +38 -0
- package/dist/{push-index-prebuild-DR3P4yOw.js → push-index-prebuild-C6wKdjYV.js} +3 -3
- package/dist/{push-index-prebuild-DR3P4yOw.js.map → push-index-prebuild-C6wKdjYV.js.map} +1 -1
- package/dist/{push-legacy-renames-BIxBmVLl.js → push-legacy-renames-BFF72tHG.js} +3 -3
- package/dist/{push-legacy-renames-BIxBmVLl.js.map → push-legacy-renames-BFF72tHG.js.map} +1 -1
- package/dist/{push-policy-plan-BHsasXa7.js → push-policy-plan-lOTPeQ1u.js} +2 -2
- package/dist/{push-policy-plan-BHsasXa7.js.map → push-policy-plan-lOTPeQ1u.js.map} +1 -1
- package/dist/read-routing.d.ts +139 -0
- package/dist/schema/deferred-index-build.d.ts +9 -0
- package/dist/schema/introspect-db.js +1 -1
- package/dist/{websocket-D4wrzF3b.js → websocket-CCJnghvG.js} +2 -2
- package/dist/{websocket-D4wrzF3b.js.map → websocket-CCJnghvG.js.map} +1 -1
- package/package.json +7 -7
- package/dist/connection-czvI7TZL.js.map +0 -1
- package/dist/open-rebase-D9n8idex.js.map +0 -1
|
@@ -0,0 +1,38 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Running behind a transaction-mode pooler (PgBouncer, `DATABASE_POOLED=true`).
|
|
3
|
+
*
|
|
4
|
+
* The pool sends no session settings at connect behind one — the pooler would
|
|
5
|
+
* refuse or drop them — and a transaction sets its own (`SET LOCAL`, see
|
|
6
|
+
* `pooledTransactionSettings`). What that leaves is a statement outside any
|
|
7
|
+
* transaction: it runs with the role's defaults, and the default
|
|
8
|
+
* `search_path` is `"$user", public`. This framework's role is usually called
|
|
9
|
+
* `rebase`, and so is its schema, so an unqualified table resolves to
|
|
10
|
+
* `rebase.<name>` before `public.<name>` — the hazard `pinSearchPath` exists
|
|
11
|
+
* for, which a pooled pool cannot pin.
|
|
12
|
+
*
|
|
13
|
+
* So the boot gives the role a default `search_path` of `public` in this
|
|
14
|
+
* database, the same value every direct connection of this framework already
|
|
15
|
+
* pins, over the direct URL. It applies to server connections the pooler opens
|
|
16
|
+
* from then on.
|
|
17
|
+
*
|
|
18
|
+
* @module
|
|
19
|
+
*/
|
|
20
|
+
import { type Pool } from "pg";
|
|
21
|
+
/** The statement that gives `role` a default `search_path` in `database`. */
|
|
22
|
+
export declare function roleSearchPathStatement(role: string, database: string, searchPath: string): string;
|
|
23
|
+
/** Whether a reported `search_path` already is `wanted`, spelling aside. */
|
|
24
|
+
export declare function searchPathMatches(reported: string, wanted: string): boolean;
|
|
25
|
+
/**
|
|
26
|
+
* Make the role the pooled pool connects as default to `searchPath` in its
|
|
27
|
+
* database, when it does not already. Asked through the pool (what the pooler
|
|
28
|
+
* hands out is what matters), changed through `directUrl`.
|
|
29
|
+
*
|
|
30
|
+
* With `provision: false` — a boot that runs no DDL — nothing is changed and
|
|
31
|
+
* the statement to run is logged. A role that may not change its own
|
|
32
|
+
* defaults is logged the same way; neither stops the boot, because every
|
|
33
|
+
* transaction still sets the path for itself.
|
|
34
|
+
*/
|
|
35
|
+
export declare function ensurePooledRoleDefaults(pool: Pick<Pool, "query">, directUrl: string, options: {
|
|
36
|
+
provision: boolean;
|
|
37
|
+
searchPath?: string;
|
|
38
|
+
}): Promise<void>;
|
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
import { createRequire as __createRequire } from "module";
|
|
2
2
|
__createRequire(import.meta.url);
|
|
3
3
|
import { n as planSchema } from "./plan-schema-DMVh77yb.js";
|
|
4
|
-
import { s as diffPlanAgainstCatalogue } from "./deferred-index-build-
|
|
5
|
-
import { i as readExistingSchema } from "./ensure-collection-tables-
|
|
4
|
+
import { s as diffPlanAgainstCatalogue } from "./deferred-index-build-BwH6k1Og.js";
|
|
5
|
+
import { i as readExistingSchema } from "./ensure-collection-tables-DvaCEy6X.js";
|
|
6
6
|
import { declaredDatabaseExtensions } from "@rebasepro/types";
|
|
7
7
|
//#region src/schema/push-index-prebuild.ts
|
|
8
8
|
/**
|
|
@@ -42,4 +42,4 @@ async function missingForeignKeyIndexes(client, collections) {
|
|
|
42
42
|
//#endregion
|
|
43
43
|
export { missingForeignKeyIndexes };
|
|
44
44
|
|
|
45
|
-
//# sourceMappingURL=push-index-prebuild-
|
|
45
|
+
//# sourceMappingURL=push-index-prebuild-C6wKdjYV.js.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"push-index-prebuild-
|
|
1
|
+
{"version":3,"file":"push-index-prebuild-C6wKdjYV.js","names":[],"sources":["../src/schema/push-index-prebuild.ts"],"sourcesContent":["/**\n * The foreign-key indexes `rebase db push` builds before Atlas plans.\n *\n * Rebase derives a btree for every `belongsTo` key and every junction's target\n * column (15b00afcd). On a table that already exists — every table of a\n * project upgraded across that release — the index is missing, and a push left\n * it to Atlas, which builds it inside the push's one transaction: a plain\n * `CREATE INDEX`, holding writes to the table for the whole build, about 0.4 s\n * at a million rows and 6 s at ten million. Atlas's own concurrent mode would\n * run the entire apply outside a transaction, which the push relies on.\n *\n * So the push builds those first, `CONCURRENTLY`, with the builder the boot\n * uses for the same indexes (`deferred-index-build.ts`: one at a time, a lock\n * budget for getting the table, an INVALID leftover dropped and rebuilt, a\n * claim shared with booting instances). Atlas then finds them and plans\n * nothing for them. One it could not build is still Atlas's, as before.\n *\n * Only an index whose columns are already there: a column this push adds is\n * created by Atlas, and its index with it, on a column that holds no values.\n */\nimport { declaredDatabaseExtensions, type CollectionConfig } from \"@rebasepro/types\";\nimport { planSchema } from \"./plan/plan-schema\";\nimport { diffPlanAgainstCatalogue, type DeferredIndexBuild } from \"./plan/diff-plan\";\nimport { readExistingSchema, type Queryable } from \"./ensure-collection-tables\";\n\n/** The derived foreign-key indexes a live table lacks (or holds INVALID) whose columns it already has. */\nexport async function missingForeignKeyIndexes(\n client: Queryable,\n collections: CollectionConfig[]\n): Promise<DeferredIndexBuild[]> {\n const schema = planSchema(collections, { databaseExtensions: declaredDatabaseExtensions() });\n const schemas = Array.from(new Set(schema.tables.map(table => table.schema)));\n // No row probes: whether a table holds rows decides only constraints on a\n // column being added, which this does not plan.\n const existing = await readExistingSchema(client, schemas, { probeTables: () => [] });\n const plan = diffPlanAgainstCatalogue(schema, existing);\n\n const specs = new Map(schema.tables.flatMap(table => table.indexes)\n .map(spec => [`${spec.schema}.${spec.indexName}`, spec]));\n return plan.deferredIndexes.filter(build => {\n const spec = specs.get(`${build.schema}.${build.indexName}`);\n if (spec?.derived !== \"foreign-key\") return false;\n const columns = existing.tables.get(`${build.schema}.${build.table}`);\n if (!columns) return false;\n return [...spec.keys.map(key => key.column), ...spec.include].every(column => columns.has(column));\n });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,eAAsB,yBAClB,QACA,aAC6B;CAC7B,MAAM,SAAS,WAAW,aAAa,EAAE,oBAAoB,2BAA2B,EAAE,CAAC;CAI3F,MAAM,WAAW,MAAM,mBAAmB,QAH1B,MAAM,KAAK,IAAI,IAAI,OAAO,OAAO,KAAI,UAAS,MAAM,MAAM,CAAC,CAGzB,GAAS,EAAE,mBAAmB,CAAC,EAAE,CAAC;CACpF,MAAM,OAAO,yBAAyB,QAAQ,QAAQ;CAEtD,MAAM,QAAQ,IAAI,IAAI,OAAO,OAAO,SAAQ,UAAS,MAAM,OAAO,CAAC,CAC9D,KAAI,SAAQ,CAAC,GAAG,KAAK,OAAO,GAAG,KAAK,aAAa,IAAI,CAAC,CAAC;CAC5D,OAAO,KAAK,gBAAgB,QAAO,UAAS;EACxC,MAAM,OAAO,MAAM,IAAI,GAAG,MAAM,OAAO,GAAG,MAAM,WAAW;EAC3D,IAAI,MAAM,YAAY,eAAe,OAAO;EAC5C,MAAM,UAAU,SAAS,OAAO,IAAI,GAAG,MAAM,OAAO,GAAG,MAAM,OAAO;EACpE,IAAI,CAAC,SAAS,OAAO;EACrB,OAAO,CAAC,GAAG,KAAK,KAAK,KAAI,QAAO,IAAI,MAAM,GAAG,GAAG,KAAK,OAAO,CAAC,CAAC,OAAM,WAAU,QAAQ,IAAI,MAAM,CAAC;CACrG,CAAC;AACL"}
|
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
import { createRequire as __createRequire } from "module";
|
|
2
2
|
__createRequire(import.meta.url);
|
|
3
3
|
import { n as planSchema } from "./plan-schema-DMVh77yb.js";
|
|
4
|
-
import { s as diffPlanAgainstCatalogue } from "./deferred-index-build-
|
|
5
|
-
import { i as readExistingSchema } from "./ensure-collection-tables-
|
|
4
|
+
import { s as diffPlanAgainstCatalogue } from "./deferred-index-build-BwH6k1Og.js";
|
|
5
|
+
import { i as readExistingSchema } from "./ensure-collection-tables-DvaCEy6X.js";
|
|
6
6
|
import { declaredDatabaseExtensions } from "@rebasepro/types";
|
|
7
7
|
//#region src/schema/push-legacy-renames.ts
|
|
8
8
|
/**
|
|
@@ -31,4 +31,4 @@ async function legacyForeignKeyRenames(client, collections) {
|
|
|
31
31
|
//#endregion
|
|
32
32
|
export { legacyForeignKeyRenames };
|
|
33
33
|
|
|
34
|
-
//# sourceMappingURL=push-legacy-renames-
|
|
34
|
+
//# sourceMappingURL=push-legacy-renames-BFF72tHG.js.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"push-legacy-renames-
|
|
1
|
+
{"version":3,"file":"push-legacy-renames-BFF72tHG.js","names":[],"sources":["../src/schema/push-legacy-renames.ts"],"sourcesContent":["/**\n * The relation columns an aged database still holds under the name Rebase\n * derived before 0.13 (`categorie_id`, `people_id`), for `db push` to rename\n * before Atlas plans.\n *\n * Boot renames them losslessly (`diff-plan.ts`, `renameLegacyColumn`). Push\n * runs Atlas, which sees only \"drop `categorie_id`, add `category_id` NOT\n * NULL\": it listed the links as destructive changes to approve, and with\n * `--allow-destructive` dropped them. A pipeline that runs only `db push`\n * could not upgrade an aged database at all. Renaming first — the same\n * metadata-only statement boot runs — leaves Atlas nothing to plan.\n */\nimport { declaredDatabaseExtensions, type CollectionConfig } from \"@rebasepro/types\";\nimport { planSchema } from \"./plan/plan-schema\";\nimport { diffPlanAgainstCatalogue, type LegacyForeignKey } from \"./plan/diff-plan\";\nimport { readExistingSchema, type Queryable } from \"./ensure-collection-tables\";\n\nexport interface LegacyRename extends LegacyForeignKey {\n /** `ALTER TABLE … RENAME COLUMN …;` */\n sql: string;\n}\n\nexport async function legacyForeignKeyRenames(client: Queryable, collections: CollectionConfig[]): Promise<LegacyRename[]> {\n const schema = planSchema(collections, { databaseExtensions: declaredDatabaseExtensions() });\n const schemas = Array.from(new Set(schema.tables.map(table => table.schema)));\n const existing = await readExistingSchema(client, schemas, { probeTables: () => [] });\n const plan = diffPlanAgainstCatalogue(schema, existing);\n return plan.legacyForeignKeys.map(legacy => {\n const action = plan.actions.find(a => a.kind === \"rename-column\" && a.target === `${legacy.table}.${legacy.expected}`);\n return { ...legacy, sql: action?.sql ?? \"\" };\n }).filter(rename => rename.sql !== \"\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAsBA,eAAsB,wBAAwB,QAAmB,aAA0D;CACvH,MAAM,SAAS,WAAW,aAAa,EAAE,oBAAoB,2BAA2B,EAAE,CAAC;CAG3F,MAAM,OAAO,yBAAyB,QAAQ,MADvB,mBAAmB,QAD1B,MAAM,KAAK,IAAI,IAAI,OAAO,OAAO,KAAI,UAAS,MAAM,MAAM,CAAC,CACzB,GAAS,EAAE,mBAAmB,CAAC,EAAE,CAAC,CAC9B;CACtD,OAAO,KAAK,kBAAkB,KAAI,WAAU;EACxC,MAAM,SAAS,KAAK,QAAQ,MAAK,MAAK,EAAE,SAAS,mBAAmB,EAAE,WAAW,GAAG,OAAO,MAAM,GAAG,OAAO,UAAU;EACrH,OAAO;GAAE,GAAG;GAAQ,KAAK,QAAQ,OAAO;EAAG;CAC/C,CAAC,CAAC,CAAC,QAAO,WAAU,OAAO,QAAQ,EAAE;AACzC"}
|
|
@@ -2,7 +2,7 @@ import { createRequire as __createRequire } from "module";
|
|
|
2
2
|
__createRequire(import.meta.url);
|
|
3
3
|
import { n as generatePostgresPoliciesDdl } from "./generate-postgres-ddl-logic-0rbAqwYT.js";
|
|
4
4
|
import { a as parseExpectedPolicies, o as partitionOrphans, t as checkPolicyDrift } from "./policy-drift-0Cp4Lc0x.js";
|
|
5
|
-
import { probeRenderedPolicies, readPolicyStamps, tablesRlsWouldEnable } from "./ensure-collection-policies-
|
|
5
|
+
import { probeRenderedPolicies, readPolicyStamps, tablesRlsWouldEnable } from "./ensure-collection-policies-f0LIwiwp.js";
|
|
6
6
|
//#region src/schema/push-policy-plan.ts
|
|
7
7
|
var keyOf = (p) => `${p.schema}.${p.table}.${p.name}`;
|
|
8
8
|
/** What a stamp that no longer matches says. */
|
|
@@ -124,4 +124,4 @@ async function underSearchPath(client, searchPath, read) {
|
|
|
124
124
|
//#endregion
|
|
125
125
|
export { formatPolicyPushPlan, planPolicyPush, summarizePolicyPushPlan, underSearchPath };
|
|
126
126
|
|
|
127
|
-
//# sourceMappingURL=push-policy-plan-
|
|
127
|
+
//# sourceMappingURL=push-policy-plan-lOTPeQ1u.js.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"push-policy-plan-BHsasXa7.js","names":[],"sources":["../src/schema/push-policy-plan.ts"],"sourcesContent":["/**\n * What `rebase db push` will do to row-level security, read before it does it.\n *\n * Atlas has no model for a policy: its free tier neither plans nor reads one.\n * So its plan, which was everything `db push --dry-run` showed, never named\n * one. After `schema introspect` on a database whose tables had policies of\n * their own and no admin baseline, the dry run said \"No changes: the database\n * already matches these collections\", and the push then created eight\n * `<table>_default_admin_*` policies that let an admin read and write every\n * row.\n *\n * The plan is the push's own steps, read instead of run:\n *\n * - **RLS switched on:** the tables `lockCollectionTables` switches on\n * ({@link tablesRlsWouldEnable}).\n * - **Policies created and replaced:** `policies.sql`, which DROPs and CREATEs\n * every declared policy, against the database as `checkPolicyDrift` reads\n * it: by name, `TO` list, command, mode and which clauses there are. Text\n * is compared through the stamp the push and every boot write\n * ({@link readPolicyStamps}), which is what catches a rule whose SQL changed\n * under the same name. Where the stamp does not match, or there is none (a\n * policy `db migrate` or a hand made), the policy is made again under a probe\n * name and rolled back ({@link probeRenderedPolicies}): one Postgres would\n * store exactly as it is now is no change. Only one that could not be probed\n * is listed as unstamped.\n * - **Policies dropped and kept:** {@link partitionOrphans}, which is how the\n * push's reconcile step decides.\n */\nimport type { CollectionConfig } from \"@rebasepro/types\";\nimport {\n checkPolicyDrift,\n parseExpectedPolicies,\n partitionOrphans,\n type PolicyRef,\n type Queryable\n} from \"../security/policy-drift\";\nimport { generatePostgresPoliciesDdl } from \"./generate-postgres-ddl-logic\";\nimport { probeRenderedPolicies, readPolicyStamps, tablesRlsWouldEnable } from \"./ensure-collection-policies\";\n\nexport interface PolicyPushPlan {\n /** Declared tables in the database with row-level security off, as `schema.table`: the push switches it on. */\n enableRls: string[];\n /** Declared policies the database does not have: the push creates them. */\n create: PolicyRef[];\n /** Declared policies the database has under the same name, defined otherwise: the push replaces them. */\n replace: { policy: PolicyRef; why: string[] }[];\n /** Policies an earlier push generated from a rule edited since: the push drops them. */\n drop: PolicyRef[];\n /** Policies no collection describes, which the push leaves in force. */\n keep: PolicyRef[];\n /** Declared policies the database has with no stamp of Rebase's: re-created from their rules, changed or not. */\n unstamped: PolicyRef[];\n}\n\nconst keyOf = (p: PolicyRef): string => `${p.schema}.${p.table}.${p.name}`;\n\n/** What a stamp that no longer matches says. */\nconst STALE = \"its rule, or the policy itself, has changed since Rebase wrote it\";\n\n/** What a policy with no stamp, whose rule stores something else, says. */\nconst UNSTAMPED_DIFFERS = \"it carries no stamp of Rebase's, and its rule defines it otherwise\";\n\n/**\n * Read the plan.\n *\n * @param options.searchPath the `search_path` the stamps were written under\n * when the connection's own differs — the one `db push` stamps under.\n * See {@link readPolicyStamps}.\n */\nexport async function planPolicyPush(\n client: Queryable,\n collections: CollectionConfig[],\n options: { searchPath?: string } = {}\n): Promise<PolicyPushPlan> {\n const drift = await checkPolicyDrift(client, collections);\n const { dropped, kept } = partitionOrphans(drift, collections);\n const enableRls = await tablesRlsWouldEnable(client, collections);\n const stamps = await underSearchPath(client, options.searchPath, () => readPolicyStamps(client, collections));\n\n const replace = drift.diverged.map(d => ({ policy: d.expected, why: d.differences }));\n const settled = new Set([...drift.missing, ...drift.diverged.map(d => d.expected)].map(keyOf));\n const unsure: { policy: PolicyRef; state: \"stale\" | \"unstamped\" }[] = [];\n for (const policy of parseExpectedPolicies(generatePostgresPoliciesDdl(collections))) {\n if (settled.has(keyOf(policy))) continue;\n const state = stamps.get(`${policy.schema}.${policy.table}`)?.get(policy.name);\n if (state === \"stale\" || state === \"unstamped\") unsure.push({ policy, state });\n }\n // What the stamp cannot say, asked of Postgres: would the push store the\n // definition that is there? A policy it would re-create exactly is no change.\n const rendersAsStored = unsure.length === 0\n ? new Map<string, boolean>()\n : await probeRenderedPolicies(client, collections, unsure.map(entry => entry.policy), { searchPath: options.searchPath });\n const unstamped: PolicyRef[] = [];\n for (const { policy, state } of unsure) {\n const same = rendersAsStored.get(keyOf(policy));\n if (same === true) continue;\n if (state === \"stale\") replace.push({ policy, why: [STALE] });\n else if (same === false) replace.push({ policy, why: [UNSTAMPED_DIFFERS] });\n else unstamped.push(policy);\n }\n\n return { enableRls, create: drift.missing, replace, drop: dropped, keep: kept, unstamped };\n}\n\n/** Whether the push would change any row-level security. Kept and unstamped policies are not changes. */\nexport function policyPlanChanges(plan: PolicyPushPlan): boolean {\n return plan.enableRls.length + plan.create.length + plan.replace.length + plan.drop.length > 0;\n}\n\nconst describe = (p: PolicyRef): string => `${p.schema}.${p.table} → \"${p.name}\" (${p.command} TO ${p.roles.join(\", \")})`;\n\n/**\n * The plan as `db push --dry-run` prints it: `changes`, what the push does,\n * and `notes`, what it leaves or cannot tell. Both empty when there is\n * nothing to say.\n */\nexport function formatPolicyPushPlan(plan: PolicyPushPlan): { changes: string[]; notes: string[] } {\n const changes: string[] = [];\n if (policyPlanChanges(plan)) {\n changes.push(\" Planned row-level security changes:\");\n for (const table of plan.enableRls) changes.push(` switch RLS on ${table}`);\n for (const p of plan.create) changes.push(` create policy ${describe(p)}`);\n for (const { policy, why } of plan.replace) changes.push(` replace policy ${describe(policy)}: ${why.join(\"; \")}`);\n for (const p of plan.drop) changes.push(` drop policy ${describe(p)}, left by a rule edited since`);\n }\n\n const notes: string[] = [];\n if (plan.unstamped.length > 0) {\n notes.push(` ${plan.unstamped.length} declared ${plan.unstamped.length === 1 ? \"policy carries\" : \"policies carry\"} ` +\n \"no stamp of Rebase's, so the push re-creates each from its rule\");\n notes.push(\" and cannot tell beforehand whether that changes it:\");\n for (const p of plan.unstamped) notes.push(` ${describe(p)}`);\n }\n if (plan.keep.length > 0) {\n notes.push(\" Policies in the database that no collection describes, which the push leaves in force:\");\n for (const p of plan.keep) notes.push(` ${describe(p)}`);\n }\n return { changes, notes };\n}\n\n/** One line for the push itself: the counts, or `null` when it changes no row-level security. */\nexport function summarizePolicyPushPlan(plan: PolicyPushPlan): string | null {\n if (!policyPlanChanges(plan)) return null;\n const count = (n: number, one: string, many: string): string => `${n} ${n === 1 ? one : many}`;\n const parts = [\n plan.create.length > 0 ? count(plan.create.length, \"policy to create\", \"policies to create\") : \"\",\n plan.replace.length > 0 ? `${plan.replace.length} to replace` : \"\",\n plan.drop.length > 0 ? `${plan.drop.length} to drop` : \"\",\n plan.enableRls.length > 0 ? `RLS to switch on for ${count(plan.enableRls.length, \"table\", \"tables\")}` : \"\"\n ].filter(Boolean);\n return ` Row-level security: ${parts.join(\", \")}. \\`rebase db push --dry-run\\` lists them.`;\n}\n\n/**\n * Run `read` under `searchPath`, set for one transaction and gone after it, or\n * as the connection is when there is none to set.\n */\nexport async function underSearchPath<T>(client: Queryable, searchPath: string | undefined, read: () => Promise<T>): Promise<T> {\n if (!searchPath) return read();\n await client.query(\"BEGIN\");\n try {\n await client.query(`SET LOCAL search_path TO ${searchPath}`);\n const result = await read();\n await client.query(\"COMMIT\");\n return result;\n } catch (err) {\n await client.query(\"ROLLBACK\").catch(() => undefined);\n throw err;\n }\n}\n"],"mappings":"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"}
|
|
1
|
+
{"version":3,"file":"push-policy-plan-lOTPeQ1u.js","names":[],"sources":["../src/schema/push-policy-plan.ts"],"sourcesContent":["/**\n * What `rebase db push` will do to row-level security, read before it does it.\n *\n * Atlas has no model for a policy: its free tier neither plans nor reads one.\n * So its plan, which was everything `db push --dry-run` showed, never named\n * one. After `schema introspect` on a database whose tables had policies of\n * their own and no admin baseline, the dry run said \"No changes: the database\n * already matches these collections\", and the push then created eight\n * `<table>_default_admin_*` policies that let an admin read and write every\n * row.\n *\n * The plan is the push's own steps, read instead of run:\n *\n * - **RLS switched on:** the tables `lockCollectionTables` switches on\n * ({@link tablesRlsWouldEnable}).\n * - **Policies created and replaced:** `policies.sql`, which DROPs and CREATEs\n * every declared policy, against the database as `checkPolicyDrift` reads\n * it: by name, `TO` list, command, mode and which clauses there are. Text\n * is compared through the stamp the push and every boot write\n * ({@link readPolicyStamps}), which is what catches a rule whose SQL changed\n * under the same name. Where the stamp does not match, or there is none (a\n * policy `db migrate` or a hand made), the policy is made again under a probe\n * name and rolled back ({@link probeRenderedPolicies}): one Postgres would\n * store exactly as it is now is no change. Only one that could not be probed\n * is listed as unstamped.\n * - **Policies dropped and kept:** {@link partitionOrphans}, which is how the\n * push's reconcile step decides.\n */\nimport type { CollectionConfig } from \"@rebasepro/types\";\nimport {\n checkPolicyDrift,\n parseExpectedPolicies,\n partitionOrphans,\n type PolicyRef,\n type Queryable\n} from \"../security/policy-drift\";\nimport { generatePostgresPoliciesDdl } from \"./generate-postgres-ddl-logic\";\nimport { probeRenderedPolicies, readPolicyStamps, tablesRlsWouldEnable } from \"./ensure-collection-policies\";\n\nexport interface PolicyPushPlan {\n /** Declared tables in the database with row-level security off, as `schema.table`: the push switches it on. */\n enableRls: string[];\n /** Declared policies the database does not have: the push creates them. */\n create: PolicyRef[];\n /** Declared policies the database has under the same name, defined otherwise: the push replaces them. */\n replace: { policy: PolicyRef; why: string[] }[];\n /** Policies an earlier push generated from a rule edited since: the push drops them. */\n drop: PolicyRef[];\n /** Policies no collection describes, which the push leaves in force. */\n keep: PolicyRef[];\n /** Declared policies the database has with no stamp of Rebase's: re-created from their rules, changed or not. */\n unstamped: PolicyRef[];\n}\n\nconst keyOf = (p: PolicyRef): string => `${p.schema}.${p.table}.${p.name}`;\n\n/** What a stamp that no longer matches says. */\nconst STALE = \"its rule, or the policy itself, has changed since Rebase wrote it\";\n\n/** What a policy with no stamp, whose rule stores something else, says. */\nconst UNSTAMPED_DIFFERS = \"it carries no stamp of Rebase's, and its rule defines it otherwise\";\n\n/**\n * Read the plan.\n *\n * @param options.searchPath the `search_path` the stamps were written under\n * when the connection's own differs — the one `db push` stamps under.\n * See {@link readPolicyStamps}.\n */\nexport async function planPolicyPush(\n client: Queryable,\n collections: CollectionConfig[],\n options: { searchPath?: string } = {}\n): Promise<PolicyPushPlan> {\n const drift = await checkPolicyDrift(client, collections);\n const { dropped, kept } = partitionOrphans(drift, collections);\n const enableRls = await tablesRlsWouldEnable(client, collections);\n const stamps = await underSearchPath(client, options.searchPath, () => readPolicyStamps(client, collections));\n\n const replace = drift.diverged.map(d => ({ policy: d.expected, why: d.differences }));\n const settled = new Set([...drift.missing, ...drift.diverged.map(d => d.expected)].map(keyOf));\n const unsure: { policy: PolicyRef; state: \"stale\" | \"unstamped\" }[] = [];\n for (const policy of parseExpectedPolicies(generatePostgresPoliciesDdl(collections))) {\n if (settled.has(keyOf(policy))) continue;\n const state = stamps.get(`${policy.schema}.${policy.table}`)?.get(policy.name);\n if (state === \"stale\" || state === \"unstamped\") unsure.push({ policy, state });\n }\n // What the stamp cannot say, asked of Postgres: would the push store the\n // definition that is there? A policy it would re-create exactly is no change.\n const rendersAsStored = unsure.length === 0\n ? new Map<string, boolean>()\n : await probeRenderedPolicies(client, collections, unsure.map(entry => entry.policy), { searchPath: options.searchPath });\n const unstamped: PolicyRef[] = [];\n for (const { policy, state } of unsure) {\n const same = rendersAsStored.get(keyOf(policy));\n if (same === true) continue;\n if (state === \"stale\") replace.push({ policy, why: [STALE] });\n else if (same === false) replace.push({ policy, why: [UNSTAMPED_DIFFERS] });\n else unstamped.push(policy);\n }\n\n return { enableRls, create: drift.missing, replace, drop: dropped, keep: kept, unstamped };\n}\n\n/** Whether the push would change any row-level security. Kept and unstamped policies are not changes. */\nexport function policyPlanChanges(plan: PolicyPushPlan): boolean {\n return plan.enableRls.length + plan.create.length + plan.replace.length + plan.drop.length > 0;\n}\n\nconst describe = (p: PolicyRef): string => `${p.schema}.${p.table} → \"${p.name}\" (${p.command} TO ${p.roles.join(\", \")})`;\n\n/**\n * The plan as `db push --dry-run` prints it: `changes`, what the push does,\n * and `notes`, what it leaves or cannot tell. Both empty when there is\n * nothing to say.\n */\nexport function formatPolicyPushPlan(plan: PolicyPushPlan): { changes: string[]; notes: string[] } {\n const changes: string[] = [];\n if (policyPlanChanges(plan)) {\n changes.push(\" Planned row-level security changes:\");\n for (const table of plan.enableRls) changes.push(` switch RLS on ${table}`);\n for (const p of plan.create) changes.push(` create policy ${describe(p)}`);\n for (const { policy, why } of plan.replace) changes.push(` replace policy ${describe(policy)}: ${why.join(\"; \")}`);\n for (const p of plan.drop) changes.push(` drop policy ${describe(p)}, left by a rule edited since`);\n }\n\n const notes: string[] = [];\n if (plan.unstamped.length > 0) {\n notes.push(` ${plan.unstamped.length} declared ${plan.unstamped.length === 1 ? \"policy carries\" : \"policies carry\"} ` +\n \"no stamp of Rebase's, so the push re-creates each from its rule\");\n notes.push(\" and cannot tell beforehand whether that changes it:\");\n for (const p of plan.unstamped) notes.push(` ${describe(p)}`);\n }\n if (plan.keep.length > 0) {\n notes.push(\" Policies in the database that no collection describes, which the push leaves in force:\");\n for (const p of plan.keep) notes.push(` ${describe(p)}`);\n }\n return { changes, notes };\n}\n\n/** One line for the push itself: the counts, or `null` when it changes no row-level security. */\nexport function summarizePolicyPushPlan(plan: PolicyPushPlan): string | null {\n if (!policyPlanChanges(plan)) return null;\n const count = (n: number, one: string, many: string): string => `${n} ${n === 1 ? one : many}`;\n const parts = [\n plan.create.length > 0 ? count(plan.create.length, \"policy to create\", \"policies to create\") : \"\",\n plan.replace.length > 0 ? `${plan.replace.length} to replace` : \"\",\n plan.drop.length > 0 ? `${plan.drop.length} to drop` : \"\",\n plan.enableRls.length > 0 ? `RLS to switch on for ${count(plan.enableRls.length, \"table\", \"tables\")}` : \"\"\n ].filter(Boolean);\n return ` Row-level security: ${parts.join(\", \")}. \\`rebase db push --dry-run\\` lists them.`;\n}\n\n/**\n * Run `read` under `searchPath`, set for one transaction and gone after it, or\n * as the connection is when there is none to set.\n */\nexport async function underSearchPath<T>(client: Queryable, searchPath: string | undefined, read: () => Promise<T>): Promise<T> {\n if (!searchPath) return read();\n await client.query(\"BEGIN\");\n try {\n await client.query(`SET LOCAL search_path TO ${searchPath}`);\n const result = await read();\n await client.query(\"COMMIT\");\n return result;\n } catch (err) {\n await client.query(\"ROLLBACK\").catch(() => undefined);\n throw err;\n }\n}\n"],"mappings":"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"}
|
|
@@ -0,0 +1,139 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Which connection an authenticated read runs on: the primary, or a standby
|
|
3
|
+
* (`DATABASE_READ_URL`).
|
|
4
|
+
*
|
|
5
|
+
* A standby serves a read as well as the primary does — the RLS context is
|
|
6
|
+
* transaction-local (`applyAuthContext`), and `SET LOCAL ROLE` and
|
|
7
|
+
* `set_config(…, true)` both work on a hot standby — but it serves what it
|
|
8
|
+
* has replayed, which is a little behind. Two rules keep that from being
|
|
9
|
+
* visible:
|
|
10
|
+
*
|
|
11
|
+
* - **Read-your-writes.** A principal that just wrote reads from the primary
|
|
12
|
+
* for {@link ReadRoutingOptions.stickyMs} afterwards, so a save followed by
|
|
13
|
+
* a list shows the save. In-process: another instance does not know about
|
|
14
|
+
* the write, and the lag guard is what bounds what it can serve.
|
|
15
|
+
* - **Lag guard.** The standby's replay lag is sampled every
|
|
16
|
+
* {@link ReadRoutingOptions.sampleIntervalMs}; above
|
|
17
|
+
* {@link ReadRoutingOptions.maxLagMs}, or with no recent sample, every read
|
|
18
|
+
* goes to the primary. So does every read for a while after the standby
|
|
19
|
+
* failed one (see {@link isReplicaFallbackError}), and the failed read is
|
|
20
|
+
* retried on the primary.
|
|
21
|
+
*
|
|
22
|
+
* What never comes here is decided by the caller: writes, reads inside a
|
|
23
|
+
* write's transaction, the service identity (crons, jobs, `dataAsAdmin`), and
|
|
24
|
+
* everything on the base driver — auth, realtime, idempotency, the SQL
|
|
25
|
+
* console, `rebase.sql`.
|
|
26
|
+
*
|
|
27
|
+
* @module
|
|
28
|
+
*/
|
|
29
|
+
import type { Pool } from "pg";
|
|
30
|
+
/** How reads are routed, from `REBASE_READ_STICKY_MS` / `REBASE_READ_MAX_LAG_MS`. */
|
|
31
|
+
export interface ReadRoutingOptions {
|
|
32
|
+
/** How long a principal reads from the primary after a write. Default 5000. */
|
|
33
|
+
stickyMs: number;
|
|
34
|
+
/** Replay lag above which every read goes to the primary. Default 1000. */
|
|
35
|
+
maxLagMs: number;
|
|
36
|
+
/** How often the standby's lag is sampled. Default 1000. */
|
|
37
|
+
sampleIntervalMs?: number;
|
|
38
|
+
/** How long the standby is left alone after it failed a read. Default 10 000. */
|
|
39
|
+
failureCooldownMs?: number;
|
|
40
|
+
/** Principals remembered as recent writers before the oldest is forgotten. Default 10 000. */
|
|
41
|
+
maxPinnedPrincipals?: number;
|
|
42
|
+
/** The clock, for tests. */
|
|
43
|
+
now?: () => number;
|
|
44
|
+
}
|
|
45
|
+
export declare const DEFAULT_READ_STICKY_MS = 5000;
|
|
46
|
+
export declare const DEFAULT_READ_MAX_LAG_MS = 1000;
|
|
47
|
+
/** Why a read went where it did. Reported in debug logs and tests. */
|
|
48
|
+
export type ReadRoute = {
|
|
49
|
+
target: "replica";
|
|
50
|
+
} | {
|
|
51
|
+
target: "primary";
|
|
52
|
+
reason: "sticky" | "lag" | "no-sample" | "unavailable";
|
|
53
|
+
};
|
|
54
|
+
/**
|
|
55
|
+
* Parse one of the routing variables: a whole number of milliseconds, zero
|
|
56
|
+
* allowed. A value that is set and malformed throws, naming the variable — a
|
|
57
|
+
* mistyped guard must not quietly become another number.
|
|
58
|
+
*/
|
|
59
|
+
export declare function parseReadRoutingMs(raw: string, variable: string): number;
|
|
60
|
+
/** The routing options from the environment, defaults filled in. */
|
|
61
|
+
export declare function readRoutingOptionsFromEnv(env: Record<string, string | undefined>): ReadRoutingOptions;
|
|
62
|
+
/**
|
|
63
|
+
* Whether two connection strings name the same database on the same server as
|
|
64
|
+
* the same role — ignoring the query string, where the boot pins
|
|
65
|
+
* `options=-c search_path=…` onto the primary's URL. Comparing the strings
|
|
66
|
+
* themselves is how the read pool came to be opened for a `DATABASE_READ_URL`
|
|
67
|
+
* that named the primary: the pinned primary URL never equalled the bare one.
|
|
68
|
+
*
|
|
69
|
+
* Unparseable strings are compared as given.
|
|
70
|
+
*/
|
|
71
|
+
export declare function sameDatabaseTarget(a: string, b: string): boolean;
|
|
72
|
+
/**
|
|
73
|
+
* Whether a read that failed on the standby should be run again on the
|
|
74
|
+
* primary: the standby (or the way to it) failed, anywhere down the cause
|
|
75
|
+
* chain. A policy denial, a bad filter or an error a hook threw is the read's
|
|
76
|
+
* own answer, and the primary would give it too — those are not retried, so a
|
|
77
|
+
* hook with side effects does not run twice for them.
|
|
78
|
+
*/
|
|
79
|
+
export declare function isReplicaFallbackError(error: unknown, depth?: number): boolean;
|
|
80
|
+
/**
|
|
81
|
+
* Replay lag in milliseconds, as the standby sees it: zero when it has
|
|
82
|
+
* replayed everything it received (an idle primary sends nothing, and the
|
|
83
|
+
* last replayed transaction's age would otherwise grow without bound), else
|
|
84
|
+
* the age of the last transaction it replayed. Zero on a server that is not
|
|
85
|
+
* in recovery — a read URL that names a primary has no lag. `null` when the
|
|
86
|
+
* standby cannot say.
|
|
87
|
+
*/
|
|
88
|
+
export declare const REPLICA_LAG_SQL = "SELECT CASE\n WHEN NOT pg_is_in_recovery() THEN 0\n WHEN pg_last_wal_receive_lsn() IS NOT NULL AND pg_last_wal_receive_lsn() = pg_last_wal_replay_lsn() THEN 0\n ELSE EXTRACT(EPOCH FROM (now() - pg_last_xact_replay_timestamp())) * 1000\nEND AS lag_ms";
|
|
89
|
+
/** Run {@link REPLICA_LAG_SQL} on `pool`, in milliseconds. */
|
|
90
|
+
export declare function readReplicaLagMs(pool: Pick<Pool, "query">): Promise<number | null>;
|
|
91
|
+
/**
|
|
92
|
+
* The standby's routing state for one data source: recent writers, the last
|
|
93
|
+
* lag sample, and whether the standby failed a read recently. One per source,
|
|
94
|
+
* held by the base driver, so every request's authenticated driver shares it.
|
|
95
|
+
*/
|
|
96
|
+
export declare class ReadRouter<Db = unknown> {
|
|
97
|
+
/** The standby's handle, which routed reads open their transaction on. */
|
|
98
|
+
readonly db: Db;
|
|
99
|
+
private readonly sampleLag;
|
|
100
|
+
readonly stickyMs: number;
|
|
101
|
+
readonly maxLagMs: number;
|
|
102
|
+
private readonly sampleIntervalMs;
|
|
103
|
+
private readonly failureCooldownMs;
|
|
104
|
+
private readonly maxPinned;
|
|
105
|
+
private readonly now;
|
|
106
|
+
/** Principal → when its read-your-writes window ends. Insertion order is age. */
|
|
107
|
+
private readonly pinnedUntil;
|
|
108
|
+
private lagMs;
|
|
109
|
+
private sampledAt;
|
|
110
|
+
private unavailableUntil;
|
|
111
|
+
private lastFailureWarningAt;
|
|
112
|
+
private timer?;
|
|
113
|
+
private sampling?;
|
|
114
|
+
constructor(
|
|
115
|
+
/** The standby's handle, which routed reads open their transaction on. */
|
|
116
|
+
db: Db, sampleLag: () => Promise<number | null>, options: ReadRoutingOptions);
|
|
117
|
+
/** Take the first sample and keep sampling. Unref'd: it never holds the process open. */
|
|
118
|
+
start(): void;
|
|
119
|
+
stop(): void;
|
|
120
|
+
/** One lag sample. A failed sample leaves no sample, so reads go to the primary. */
|
|
121
|
+
sample(): Promise<void>;
|
|
122
|
+
/** The last sampled lag in seconds, or `undefined` with no current sample. */
|
|
123
|
+
get lagSeconds(): number | undefined;
|
|
124
|
+
/**
|
|
125
|
+
* Where `principal`'s read goes. A read with no principal is routed on the
|
|
126
|
+
* standby's health alone: there is no write of its own to see.
|
|
127
|
+
*/
|
|
128
|
+
route(principal?: string): ReadRoute;
|
|
129
|
+
/**
|
|
130
|
+
* `principal` is writing: its reads go to the primary until
|
|
131
|
+
* {@link stickyMs} after this. Called when the write starts AND when it
|
|
132
|
+
* ends, so a read during a long write is pinned too and the window runs
|
|
133
|
+
* from the commit.
|
|
134
|
+
*/
|
|
135
|
+
notePrimaryWrite(principal: string): void;
|
|
136
|
+
/** The standby failed: leave it alone for the cooldown, and say so once a minute. */
|
|
137
|
+
noteReplicaFailure(error: unknown): void;
|
|
138
|
+
private hasFreshSample;
|
|
139
|
+
}
|
|
@@ -79,6 +79,15 @@ export declare const isPgPool: (value: unknown) => value is Pick<Pool, "connect"
|
|
|
79
79
|
* is lifted here per query.
|
|
80
80
|
*/
|
|
81
81
|
export declare const poolIndexBuildSession: (pool: Pick<Pool, "connect">) => OpenIndexBuildSession;
|
|
82
|
+
/**
|
|
83
|
+
* A session on a connection opened for it, from a URL — for a pool behind a
|
|
84
|
+
* transaction-mode pooler, where "the pool's next connection" is not one
|
|
85
|
+
* backend: the pooler hands each statement whatever server connection is
|
|
86
|
+
* free, so a session advisory lock and `SET statement_timeout = 0` would land
|
|
87
|
+
* on one and the `CREATE INDEX` run on another. The URL must name the
|
|
88
|
+
* database itself (`DATABASE_DIRECT_URL`). Ended, not released, when done.
|
|
89
|
+
*/
|
|
90
|
+
export declare const clientIndexBuildSession: (connectionString: string) => OpenIndexBuildSession;
|
|
82
91
|
export interface DeferredIndexOptions extends BootLockOptions {
|
|
83
92
|
/** Progress, one line per index. Failures are also `logger.warn`ed. */
|
|
84
93
|
log?: (message: string) => void;
|
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
import { createRequire as __createRequire } from "module";
|
|
2
2
|
__createRequire(import.meta.url);
|
|
3
3
|
import { n as require_arg, o as __toESM, t as promptConfirm } from "../cli-prompt-DXG0yk-h.js";
|
|
4
|
-
import {
|
|
4
|
+
import { u as pinSearchPath } from "../connection-CcYqncW5.js";
|
|
5
5
|
import { a as diagnoseDbError } from "../cli-errors-DYets7cp.js";
|
|
6
6
|
import { a as outWarn, i as outError, r as out, t as chalk } from "../source-fZb92pN8.js";
|
|
7
7
|
import { i as readSchemaMetadata, n as isUsableFileName, r as quoteRelation, t as countRowsUpTo } from "../introspect-db-queries-DevUrzll.js";
|
|
@@ -1,7 +1,7 @@
|
|
|
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 { A as budgetSendBuffers, M as terminateIfBacklogged, N as assertReadRequestReadable, ct as SqlResultTooLargeError, it as effectiveSqlRole, j as reapSilentSockets, lt as isNestedPath, ot as sqlRoleRanAs, st as SQL_RESULT_BYTE_BUDGET, ut as resolveNestedPath } from "./open-rebase-
|
|
4
|
+
import { A as budgetSendBuffers, M as terminateIfBacklogged, N as assertReadRequestReadable, ct as SqlResultTooLargeError, it as effectiveSqlRole, j as reapSilentSockets, lt as isNestedPath, ot as sqlRoleRanAs, st as SQL_RESULT_BYTE_BUDGET, ut as resolveNestedPath } from "./open-rebase-DvmKIu7q.js";
|
|
5
5
|
import { r as BranchingUnsupportedError } from "./BranchService-BPssiD8_.js";
|
|
6
6
|
import { ApiError, DATABASE_UNAVAILABLE_MESSAGE, RUNTIME_DEFAULT_MAX_BODY_SIZE, assertFieldOpsValid, assertNestedWriteAllowed, assertNoFieldOpsOnCreate, assertNoUserUpsert, assertUserCreationBodyValid, assertWriteRequestValid, createUserThroughAuthCollection, decideImpersonation, declaredErrorAnswer, extractUserFromToken, getAccessModel, isDatabaseUnreachable, logger, resolveConflictTarget, resolveRequireAuth, safeCompare } from "@rebasepro/server";
|
|
7
7
|
import { ANONYMOUS_USER_ID, ListLimitError, hasAdminRole, isSQLAdmin, isSchemaAdmin, resolveClientListLimit, scopeGrants, scopesForRoles } from "@rebasepro/types";
|
|
@@ -1698,4 +1698,4 @@ function createPostgresWebSocket(server, realtimeService, driver, authConfig, au
|
|
|
1698
1698
|
//#endregion
|
|
1699
1699
|
export { createPostgresWebSocket as a, websocket_exports as c, TOO_MANY_SOCKETS_CLOSE_CODE as i, PUBLIC_TYPES as n, isSocketRealtimeService as o, SESSION_ENDED_CLOSE_CODE as r, socketRealtimeMissing as s, ADMIN_PLANE_TYPES as t };
|
|
1700
1700
|
|
|
1701
|
-
//# sourceMappingURL=websocket-
|
|
1701
|
+
//# sourceMappingURL=websocket-CCJnghvG.js.map
|