@supabase/pg-delta 1.0.0-alpha.20 → 1.0.0-alpha.22

package/dist/core/catalog.diff.js

@@ -1,6 +1,6 @@
 import debug from "debug";
 import { expandReplaceDependencies } from "./expand-replace-dependencies.js";
-import { normalizePostDiffCycles } from "./post-diff-cycle-breaking.js";
+import { normalizePostDiffChanges } from "./post-diff-normalization.js";
 const debugCatalog = debug("pg-delta:catalog");
 import { diffAggregates } from "./objects/aggregate/aggregate.diff.js";
 import { DefaultPrivilegeState } from "./objects/base.default-privileges.js";
@@ -126,7 +126,7 @@ export function diffCatalogs(main, branch, options) {
     changes.push(...diffProcedures(diffContext, main.procedures, branch.procedures));
     changes.push(...diffRlsPolicies(main.rlsPolicies, branch.rlsPolicies));
     changes.push(...diffSchemas(diffContext, main.schemas, branch.schemas));
-    changes.push(...diffSequences(diffContext, main.sequences, branch.sequences, branch.tables));
+    changes.push(...diffSequences(diffContext, main.sequences, branch.sequences, branch.tables, main.tables));
     changes.push(...diffTables(diffContext, main.tables, branch.tables));
     changes.push(...diffTriggers(main.triggers, branch.triggers, branch.indexableObjects));
     changes.push(...diffEventTriggers(diffContext, main.eventTriggers, branch.eventTriggers));
@@ -159,10 +159,10 @@ export function diffCatalogs(main, branch, options) {
         mainCatalog: main,
         branchCatalog: branch,
     });
-    filteredChanges = normalizePostDiffCycles({
+    filteredChanges = normalizePostDiffChanges({
         changes: expandedDependencies.changes,
-        mainCatalog: main,
         replacedTableIds: expandedDependencies.replacedTableIds,
+        branchTables: branch.tables,
     });
     debugCatalog("changes catalog diff: %O", stringifyWithBigInt(filteredChanges, 2));
     return filteredChanges;

package/dist/core/catalog.model.d.ts

@@ -102,5 +102,12 @@ export declare class Catalog {
  * to `createPlan`.
  */
 export declare function createEmptyCatalog(version: number, currentUser: string): Promise<Catalog>;
-export declare function extractCatalog(pool: Pool): Promise<Catalog>;
+interface ExtractCatalogOptions {
+    /**
+     * Number of retry attempts for catalog extractors when `pg_get_*def()`
+     * returns NULL for at least one row. See `ExtractRetryOptions.retries`.
+     */
+    extractRetries?: number;
+}
+export declare function extractCatalog(pool: Pool, options?: ExtractCatalogOptions): Promise<Catalog>;
 export {};

package/dist/core/catalog.model.js

@@ -190,7 +190,8 @@ export async function createEmptyCatalog(version, currentUser) {
         currentUser,
     });
 }
-export async function extractCatalog(pool) {
+export async function extractCatalog(pool, options = {}) {
+    const retryOptions = { retries: options.extractRetries };
     const [aggregates, collations, compositeTypes, domains, enums, extensions, indexes, materializedViews, subscriptions, publications, procedures, rlsPolicies, roles, schemas, sequences, tables, triggers, eventTriggers, rules, ranges, views, foreignDataWrappers, servers, userMappings, foreignTables, depends, version, currentUser,] = await Promise.all([
         extractAggregates(pool).then(listToRecord),
         extractCollations(pool).then(listToRecord),
@@ -198,21 +199,21 @@ export async function extractCatalog(pool) {
         extractDomains(pool).then(listToRecord),
         extractEnums(pool).then(listToRecord),
         extractExtensions(pool).then(listToRecord),
-        extractIndexes(pool).then(listToRecord),
-        extractMaterializedViews(pool).then(listToRecord),
+        extractIndexes(pool, retryOptions).then(listToRecord),
+        extractMaterializedViews(pool, retryOptions).then(listToRecord),
         extractSubscriptions(pool).then(listToRecord),
         extractPublications(pool).then(listToRecord),
-        extractProcedures(pool).then(listToRecord),
+        extractProcedures(pool, retryOptions).then(listToRecord),
         extractRlsPolicies(pool).then(listToRecord),
         extractRoles(pool).then(listToRecord),
         extractSchemas(pool).then(listToRecord),
         extractSequences(pool).then(listToRecord),
-        extractTables(pool).then(listToRecord),
-        extractTriggers(pool).then(listToRecord),
+        extractTables(pool, retryOptions).then(listToRecord),
+        extractTriggers(pool, retryOptions).then(listToRecord),
         extractEventTriggers(pool).then(listToRecord),
-        extractRules(pool).then(listToRecord),
+        extractRules(pool, retryOptions).then(listToRecord),
         extractRanges(pool).then(listToRecord),
-        extractViews(pool).then(listToRecord),
+        extractViews(pool, retryOptions).then(listToRecord),
         extractForeignDataWrappers(pool).then(listToRecord),
         extractServers(pool).then(listToRecord),
         extractUserMappings(pool).then(listToRecord),

package/dist/core/expand-replace-dependencies.js

@@ -53,6 +53,29 @@ export function expandReplaceDependencies({ changes, mainCatalog, branchCatalog,
             replaceRoots.add(id);
         }
     }
+    // Drop-only objects (no matching create — typically a renamed-away table or
+    // type) are also expansion roots: anything in main that depends on them via
+    // pg_depend must drop before the parent does. Without this seed, a renamed
+    // table whose dependent view stays in the branch catalog (with an updated
+    // definition that no longer references the old name) would still try to
+    // run DROP TABLE old_name while old_name is referenced by the view, which
+    // PostgreSQL refuses without CASCADE. The walk below promotes the surviving
+    // dependent to DROP+CREATE so its drop is sequenced before the parent drop.
+    for (const id of droppedIds) {
+        if (createdIds.has(id))
+            continue;
+        if (replaceRoots.has(id))
+            continue;
+        // Only seed for object kinds that can have catalog dependents we know
+        // how to recreate via buildReplaceChanges.
+        if (id.startsWith("table:") ||
+            id.startsWith("view:") ||
+            id.startsWith("materializedView:") ||
+            id.startsWith("type:") ||
+            id.startsWith("domain:")) {
+            replaceRoots.add(id);
+        }
+    }
     if (replaceRoots.size === 0) {
         return {
             changes,

package/dist/core/objects/extract-with-retry.d.ts

@@ -0,0 +1,36 @@
+export interface ExtractRetryOptions {
+    /**
+     * Number of retry attempts to make when a `pg_get_*def()` call returns NULL
+     * for at least one row. Total attempts is `retries + 1`. Negative values are
+     * clamped to 0. When this option is undefined the value is read from the
+     * `PGDELTA_EXTRACT_RETRIES` environment variable, falling back to a default
+     * of 1 (i.e. the first attempt plus one retry, 2 attempts total).
+     */
+    retries?: number;
+    /**
+     * Delay between retry attempts in milliseconds; the actual wait is
+     * `backoffMs * attemptNumber` (linear). Defaults to 50. Set to 0 in tests.
+     */
+    backoffMs?: number;
+}
+export declare function resolveExtractRetries(option?: number): number;
+/**
+ * Runs `query()` up to `retries + 1` times, retrying as long as at least one
+ * row in the result satisfies `hasNullDefinition`. The retry exists because
+ * `pg_get_<x>def()` can return NULL transiently when the underlying catalog
+ * row is dropped concurrently or the catalog state is in flux; in practice a
+ * second attempt either no longer sees the dropped row or succeeds in
+ * resolving the definition.
+ *
+ * Returns the rows from the first attempt with no offenders, or — once
+ * retries are exhausted — the rows from the final attempt (still containing
+ * offenders). The caller is responsible for the final filter so this helper
+ * works for both flat schemas (definition on the row) and nested schemas
+ * (definition on a child collection, e.g. table constraints).
+ */
+export declare function extractWithDefinitionRetry<TRow>(params: {
+    label: string;
+    query: () => Promise<TRow[]>;
+    hasNullDefinition: (row: TRow) => boolean;
+    options?: ExtractRetryOptions;
+}): Promise<TRow[]>;

package/dist/core/objects/extract-with-retry.js

@@ -0,0 +1,51 @@
+import debug from "debug";
+const log = debug("pg-delta:extract");
+const DEFAULT_RETRIES = 1;
+const DEFAULT_BACKOFF_MS = 50;
+export function resolveExtractRetries(option) {
+    if (typeof option === "number" && Number.isFinite(option)) {
+        return Math.max(0, Math.floor(option));
+    }
+    const envVal = process.env.PGDELTA_EXTRACT_RETRIES;
+    if (envVal !== undefined && envVal !== "") {
+        const n = Number(envVal);
+        if (Number.isFinite(n))
+            return Math.max(0, Math.floor(n));
+    }
+    return DEFAULT_RETRIES;
+}
+const sleep = (ms) => ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
+/**
+ * Runs `query()` up to `retries + 1` times, retrying as long as at least one
+ * row in the result satisfies `hasNullDefinition`. The retry exists because
+ * `pg_get_<x>def()` can return NULL transiently when the underlying catalog
+ * row is dropped concurrently or the catalog state is in flux; in practice a
+ * second attempt either no longer sees the dropped row or succeeds in
+ * resolving the definition.
+ *
+ * Returns the rows from the first attempt with no offenders, or — once
+ * retries are exhausted — the rows from the final attempt (still containing
+ * offenders). The caller is responsible for the final filter so this helper
+ * works for both flat schemas (definition on the row) and nested schemas
+ * (definition on a child collection, e.g. table constraints).
+ */
+export async function extractWithDefinitionRetry(params) {
+    const retries = resolveExtractRetries(params.options?.retries);
+    const backoffMs = params.options?.backoffMs ?? DEFAULT_BACKOFF_MS;
+    const maxAttempts = retries + 1;
+    let rows = [];
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        rows = await params.query();
+        const offenders = rows.filter(params.hasNullDefinition).length;
+        if (offenders === 0)
+            return rows;
+        if (attempt < maxAttempts) {
+            log("%s: pg_get_*def() returned NULL for %d row(s) on attempt %d/%d; retrying", params.label, offenders, attempt, maxAttempts);
+            await sleep(backoffMs * attempt);
+        }
+        else {
+            log("%s: pg_get_*def() returned NULL for %d row(s) after %d attempt(s); skipping", params.label, offenders, maxAttempts);
+        }
+    }
+    return rows;
+}

package/dist/core/objects/index/index.diff.js

@@ -74,7 +74,6 @@ export function diffIndexes(main, branch, branchIndexableObjects) {
             "nulls_not_distinct",
             "immediate",
             "is_clustered",
-            "is_replica_identity",
             "column_collations",
             "operator_classes",
             "column_options",

package/dist/core/objects/index/index.model.d.ts

@@ -1,6 +1,7 @@
 import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../base.model.ts";
+import { type ExtractRetryOptions } from "../extract-with-retry.ts";
 declare const indexPropsSchema: z.ZodObject<{
     schema: z.ZodString;
     table_name: z.ZodString;
@@ -97,7 +98,6 @@ export declare class Index extends BasePgModel {
         nulls_not_distinct: boolean;
         immediate: boolean;
         is_clustered: boolean;
-        is_replica_identity: boolean;
         column_collations: (string | null)[];
         operator_classes: string[];
         column_options: number[];
@@ -132,7 +132,6 @@ export declare class Index extends BasePgModel {
             nulls_not_distinct: boolean;
             immediate: boolean;
             is_clustered: boolean;
-            is_replica_identity: boolean;
             index_expressions: string | null;
             partial_predicate: string | null;
             table_relkind: "r" | "m" | "p";
@@ -146,5 +145,5 @@ export declare class Index extends BasePgModel {
         };
     };
 }
-export declare function extractIndexes(pool: Pool): Promise<Index[]>;
+export declare function extractIndexes(pool: Pool, options?: ExtractRetryOptions): Promise<Index[]>;
 export {};

package/dist/core/objects/index/index.model.js

@@ -1,6 +1,7 @@
 import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../base.model.js";
+import { extractWithDefinitionRetry, } from "../extract-with-retry.js";
 const TableRelkindSchema = z.enum([
     "r", // table (regular relation)
     "m", // materialized view
@@ -136,7 +137,11 @@ export class Index extends BasePgModel {
             nulls_not_distinct: this.nulls_not_distinct,
             immediate: this.immediate,
             is_clustered: this.is_clustered,
-            is_replica_identity: this.is_replica_identity,
+            // is_replica_identity excluded: the table's `replica_identity` /
+            // `replica_identity_index` is the source of truth, set via
+            // ALTER TABLE ... REPLICA IDENTITY USING INDEX. Including this flag here
+            // would trigger spurious DROP+CREATE of the index whenever the table's
+            // replica identity changes.
             // key_columns excluded: contains attribute numbers that can differ between databases
             // even when indexes are logically identical. The definition field already captures
             // the logical structure using column names, so we compare by definition instead.
@@ -184,8 +189,13 @@ export class Index extends BasePgModel {
         };
     }
 }
-export async function extractIndexes(pool) {
-    const { rows: indexRows } = await pool.query(sql `
+export async function extractIndexes(pool, options) {
+    const indexRows = await extractWithDefinitionRetry({
+        label: "indexes",
+        options,
+        hasNullDefinition: (row) => row.definition === null,
+        query: async () => {
+            const result = await pool.query(sql `
       with extension_oids as (
         select objid
         from pg_depend d
@@ -341,8 +351,9 @@ export async function extractIndexes(pool) {
 
       order by 1, 2
   `);
-    const validatedRows = indexRows
-        .map((row) => indexRowSchema.parse(row))
-        .filter((row) => row.definition !== null);
+            return result.rows.map((row) => indexRowSchema.parse(row));
+        },
+    });
+    const validatedRows = indexRows.filter((row) => row.definition !== null);
     return validatedRows.map((row) => new Index(row));
 }

package/dist/core/objects/materialized-view/materialized-view.model.d.ts

@@ -2,6 +2,7 @@ import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel, type TableLikeObject } from "../base.model.ts";
 import { type PrivilegeProps } from "../base.privilege-diff.ts";
+import { type ExtractRetryOptions } from "../extract-with-retry.ts";
 declare const materializedViewPropsSchema: z.ZodObject<{
     schema: z.ZodString;
     name: z.ZodString;
@@ -148,5 +149,5 @@ export declare class MaterializedView extends BasePgModel implements TableLikeOb
         };
     };
 }
-export declare function extractMaterializedViews(pool: Pool): Promise<MaterializedView[]>;
+export declare function extractMaterializedViews(pool: Pool, options?: ExtractRetryOptions): Promise<MaterializedView[]>;
 export {};

package/dist/core/objects/materialized-view/materialized-view.model.js

@@ -2,6 +2,7 @@ import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel, columnPropsSchema, } from "../base.model.js";
 import { privilegePropsSchema, } from "../base.privilege-diff.js";
+import { extractWithDefinitionRetry, } from "../extract-with-retry.js";
 import { ReplicaIdentitySchema } from "../table/table.model.js";
 const materializedViewPropsSchema = z.object({
     schema: z.string(),
@@ -23,6 +24,14 @@ const materializedViewPropsSchema = z.object({
     columns: z.array(columnPropsSchema),
     privileges: z.array(privilegePropsSchema),
 });
+// pg_get_viewdef(oid) can return NULL when the underlying matview (or its
+// pg_rewrite row) is dropped between catalog scan and resolution, or under
+// transient catalog state during recovery. An unreadable matview cannot be
+// diffed, so we accept NULL here and filter the row out at extraction time
+// rather than crashing the whole catalog parse with a ZodError.
+const materializedViewRowSchema = materializedViewPropsSchema.extend({
+    definition: z.string().nullable(),
+});
 export class MaterializedView extends BasePgModel {
     schema;
     name;
@@ -114,8 +123,13 @@ export class MaterializedView extends BasePgModel {
         };
     }
 }
-export async function extractMaterializedViews(pool) {
-    const { rows: mvRows } = await pool.query(sql `
+export async function extractMaterializedViews(pool, options) {
+    const mvRows = await extractWithDefinitionRetry({
+        label: "materialized views",
+        options,
+        hasNullDefinition: (row) => row.definition === null,
+        query: async () => {
+            const result = await pool.query(sql `
 with extension_oids as (
   select
     objid
@@ -220,7 +234,9 @@ group by
 order by
   c.relnamespace::regnamespace, c.relname
   `);
-    // Validate and parse each row using the Zod schema
-    const validatedRows = mvRows.map((row) => materializedViewPropsSchema.parse(row));
+            return result.rows.map((row) => materializedViewRowSchema.parse(row));
+        },
+    });
+    const validatedRows = mvRows.filter((row) => row.definition !== null);
     return validatedRows.map((row) => new MaterializedView(row));
 }

package/dist/core/objects/procedure/procedure.model.d.ts

@@ -2,6 +2,7 @@ import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../base.model.ts";
 import { type PrivilegeProps } from "../base.privilege-diff.ts";
+import { type ExtractRetryOptions } from "../extract-with-retry.ts";
 declare const procedurePropsSchema: z.ZodObject<{
     schema: z.ZodString;
     name: z.ZodString;
@@ -128,5 +129,5 @@ export declare class Procedure extends BasePgModel {
         }[];
     };
 }
-export declare function extractProcedures(pool: Pool): Promise<Procedure[]>;
+export declare function extractProcedures(pool: Pool, options?: ExtractRetryOptions): Promise<Procedure[]>;
 export {};

package/dist/core/objects/procedure/procedure.model.js

@@ -2,6 +2,7 @@ import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../base.model.js";
 import { privilegePropsSchema, } from "../base.privilege-diff.js";
+import { extractWithDefinitionRetry, } from "../extract-with-retry.js";
 const FunctionKindSchema = z.enum([
     "f", // function
     "p", // procedure
@@ -56,6 +57,14 @@ const procedurePropsSchema = z.object({
     comment: z.string().nullable(),
     privileges: z.array(privilegePropsSchema),
 });
+// pg_get_functiondef(oid) can return NULL when the function (its pg_proc
+// row) is dropped between catalog scan and resolution, or under transient
+// catalog state. An unreadable function cannot be diffed, so we accept NULL
+// here and filter the row out at extraction time rather than crashing the
+// whole catalog parse with a ZodError.
+const procedureRowSchema = procedurePropsSchema.extend({
+    definition: z.string().nullable(),
+});
 export class Procedure extends BasePgModel {
     schema;
     name;
@@ -163,8 +172,13 @@ export class Procedure extends BasePgModel {
         };
     }
 }
-export async function extractProcedures(pool) {
-    const { rows: procedureRows } = await pool.query(sql `
+export async function extractProcedures(pool, options) {
+    const procedureRows = await extractWithDefinitionRetry({
+        label: "procedures",
+        options,
+        hasNullDefinition: (row) => row.definition === null,
+        query: async () => {
+            const result = await pool.query(sql `
 with extension_oids as (
   select
     objid
@@ -236,7 +250,9 @@ from
 order by
   1, 2
   `);
-    // Validate and parse each row using the Zod schema
-    const validatedRows = procedureRows.map((row) => procedurePropsSchema.parse(row));
+            return result.rows.map((row) => procedureRowSchema.parse(row));
+        },
+    });
+    const validatedRows = procedureRows.filter((row) => row.definition !== null);
     return validatedRows.map((row) => new Procedure(row));
 }

package/dist/core/objects/publication/changes/publication.alter.d.ts

@@ -37,7 +37,7 @@ export declare class AlterPublicationAddTables extends AlterPublicationChange {
 export declare class AlterPublicationDropTables extends AlterPublicationChange {
     readonly publication: Publication;
     readonly scope: "object";
-    private readonly tables;
+    readonly tables: PublicationTableProps[];
     constructor(props: {
         publication: Publication;
         tables: PublicationTableProps[];

package/dist/core/objects/rls-policy/rls-policy.diff.js

@@ -35,7 +35,19 @@ export function diffRlsPolicies(main, branch) {
             "permissive",
         ];
         const nonAlterablePropsChanged = hasNonAlterableChanges(mainRlsPolicy, branchRlsPolicy, NON_ALTERABLE_FIELDS, {});
-        if (nonAlterablePropsChanged) {
+        // The set of relations and procedures that the policy's USING / WITH
+        // CHECK expressions reference is recorded by PostgreSQL in pg_depend
+        // (recordDependencyOnExpr at policy creation). When that set changes
+        // it is unsafe to ALTER POLICY in place: the old reference target may
+        // be dropped in the same plan, and the new reference target may only
+        // exist after the create phase. Drop+create lets the sort phase order
+        // the policy's drop before the referenced object's drop and the
+        // policy's recreate after the referenced object's create.
+        const referencedDependenciesChanged = hasNonAlterableChanges(mainRlsPolicy, branchRlsPolicy, ["referenced_procedures", "referenced_relations"], {
+            referenced_procedures: deepEqual,
+            referenced_relations: deepEqual,
+        });
+        if (nonAlterablePropsChanged || referencedDependenciesChanged) {
             // Replace the entire RLS policy (drop + create)
             changes.push(new DropRlsPolicy({ policy: mainRlsPolicy }), new CreateRlsPolicy({ policy: branchRlsPolicy }));
         }

package/dist/core/objects/rule/rule.model.d.ts

@@ -1,6 +1,7 @@
 import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../base.model.ts";
+import { type ExtractRetryOptions } from "../extract-with-retry.ts";
 declare const RuleEnabledStateSchema: z.ZodEnum<{
     O: "O";
     D: "D";
@@ -68,5 +69,5 @@ export declare class Rule extends BasePgModel {
     };
     get relationStableId(): string;
 }
-export declare function extractRules(pool: Pool): Promise<Rule[]>;
+export declare function extractRules(pool: Pool, options?: ExtractRetryOptions): Promise<Rule[]>;
 export {};

package/dist/core/objects/rule/rule.model.js

@@ -1,6 +1,7 @@
 import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../base.model.js";
+import { extractWithDefinitionRetry, } from "../extract-with-retry.js";
 import { stableId } from "../utils.js";
 const RuleEventSchema = z.enum(["SELECT", "INSERT", "UPDATE", "DELETE"]);
 const RuleEnabledStateSchema = z.enum(["O", "D", "R", "A"]);
@@ -24,6 +25,14 @@ const rulePropsSchema = z.object({
     comment: z.string().nullable(),
     columns: z.array(z.string()),
 });
+// pg_get_ruledef(oid, pretty) can return NULL when the rule (its pg_rewrite
+// row) is dropped between catalog scan and resolution, or under transient
+// catalog state. An unreadable rule cannot be diffed, so we accept NULL here
+// and filter the row out at extraction time rather than crashing the whole
+// catalog parse with a ZodError.
+const ruleRowSchema = rulePropsSchema.extend({
+    definition: z.string().nullable(),
+});
 export class Rule extends BasePgModel {
     schema;
     name;
@@ -82,8 +91,13 @@ export class Rule extends BasePgModel {
         }
     }
 }
-export async function extractRules(pool) {
-    const { rows: ruleRows } = await pool.query(sql `
+export async function extractRules(pool, options) {
+    const ruleRows = await extractWithDefinitionRetry({
+        label: "rules",
+        options,
+        hasNullDefinition: (row) => row.definition === null,
+        query: async () => {
+            const result = await pool.query(sql `
       WITH extension_rule_oids AS (
         SELECT
           objid
@@ -149,6 +163,9 @@ export async function extractRules(pool) {
       ORDER BY
         1, 3, 2
   `);
-    const validatedRows = ruleRows.map((row) => rulePropsSchema.parse(row));
+            return result.rows.map((row) => ruleRowSchema.parse(row));
+        },
+    });
+    const validatedRows = ruleRows.filter((row) => row.definition !== null);
     return validatedRows.map((row) => new Rule(row));
 }

package/dist/core/objects/sequence/sequence.diff.d.ts

@@ -11,7 +11,8 @@ type SequenceOrColumnSetDefaultChange = AlterTableAlterColumnSetDefault | Sequen
  * @param main - The sequences in the main catalog.
  * @param branch - The sequences in the branch catalog.
  * @param branchTables - The tables in the branch catalog (used to check if owning tables are being dropped).
+ * @param mainTables - The tables in the main catalog (used to detect when a same-name sequence will be cascade-dropped because its main-side owning table is going away).
  * @returns A list of changes to apply to main to make it match branch.
  */
-export declare function diffSequences(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, Sequence>, branch: Record<string, Sequence>, branchTables?: Record<string, Table>): SequenceOrColumnSetDefaultChange[];
+export declare function diffSequences(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, Sequence>, branch: Record<string, Sequence>, branchTables?: Record<string, Table>, mainTables?: Record<string, Table>): SequenceOrColumnSetDefaultChange[];
 export {};

package/dist/core/objects/sequence/sequence.diff.js

@@ -14,9 +14,10 @@ import { GrantSequencePrivileges, RevokeGrantOptionSequencePrivileges, RevokeSeq
  * @param main - The sequences in the main catalog.
  * @param branch - The sequences in the branch catalog.
  * @param branchTables - The tables in the branch catalog (used to check if owning tables are being dropped).
+ * @param mainTables - The tables in the main catalog (used to detect when a same-name sequence will be cascade-dropped because its main-side owning table is going away).
  * @returns A list of changes to apply to main to make it match branch.
  */
-export function diffSequences(ctx, main, branch, branchTables = {}) {
+export function diffSequences(ctx, main, branch, branchTables = {}, mainTables = {}) {
     const { created, dropped, altered } = diffObjects(main, branch);
     const changes = [];
     for (const sequenceId of created) {
@@ -87,14 +88,34 @@ export function diffSequences(ctx, main, branch, branchTables = {}) {
         const branchSequence = branch[sequenceId];
         // Check if non-alterable properties have changed
         // These require dropping and recreating the sequence
-        const NON_ALTERABLE_FIELDS = [
-            "data_type",
-            "persistence",
-        ];
+        const NON_ALTERABLE_FIELDS = ["persistence"];
         const nonAlterablePropsChanged = hasNonAlterableChanges(mainSequence, branchSequence, NON_ALTERABLE_FIELDS);
-        if (nonAlterablePropsChanged) {
-            // Replace the entire sequence (drop + create)
-            changes.push(new DropSequence({ sequence: mainSequence }), new CreateSequence({ sequence: branchSequence }));
+        // A sequence kept the same name (so it's "altered" in catalog terms),
+        // but its main-side owning table is going away from the plan (renamed
+        // away or simply dropped). PostgreSQL will cascade-drop the sequence
+        // alongside the table, leaving any later CREATE TABLE / column-default
+        // that depends on the sequence name pointing at nothing. Treat this
+        // like a non-alterable change so we recreate the sequence after the
+        // owning table is dropped.
+        const mainOwnedByTableId = mainSequence.owned_by_schema && mainSequence.owned_by_table
+            ? `table:${mainSequence.owned_by_schema}.${mainSequence.owned_by_table}`
+            : null;
+        const cascadeOrphanedByOwningTable = mainOwnedByTableId !== null &&
+            mainTables[mainOwnedByTableId] !== undefined &&
+            branchTables[mainOwnedByTableId] === undefined;
+        if (nonAlterablePropsChanged || cascadeOrphanedByOwningTable) {
+            // When the owning table is going away in this plan, PostgreSQL will
+            // cascade-drop the sequence as part of the DROP TABLE. Emitting an
+            // explicit DROP SEQUENCE here would (a) introduce an unbreakable
+            // DropSequence ↔ DropTable cycle on the catalog edges between the
+            // sequence and the dropped column, and (b) be redundant with the
+            // cascade. The CreateSequence below restores the sequence under its
+            // original name so any same-name reference in a later CREATE TABLE
+            // resolves correctly.
+            if (!cascadeOrphanedByOwningTable) {
+                changes.push(new DropSequence({ sequence: mainSequence }));
+            }
+            changes.push(new CreateSequence({ sequence: branchSequence }));
             // Re-apply OWNED BY if present on branch
             if (branchSequence.owned_by_schema !== null &&
                 branchSequence.owned_by_table !== null &&
@@ -131,7 +152,8 @@ export function diffSequences(ctx, main, branch, branchTables = {}) {
         }
         else {
             // Only alterable properties changed - emit ALTER for options/owner
-            const optionsChanged = mainSequence.increment !== branchSequence.increment ||
+            const optionsChanged = mainSequence.data_type !== branchSequence.data_type ||
+                mainSequence.increment !== branchSequence.increment ||
                 mainSequence.minimum_value !== branchSequence.minimum_value ||
                 mainSequence.maximum_value !== branchSequence.maximum_value ||
                 mainSequence.start_value !== branchSequence.start_value ||
@@ -139,6 +161,16 @@ export function diffSequences(ctx, main, branch, branchTables = {}) {
                 mainSequence.cycle_option !== branchSequence.cycle_option;
             if (optionsChanged) {
                 const options = [];
+                // `AS <type>` must come before any MIN/MAX/RESTART clauses per the
+                // PG ALTER SEQUENCE grammar. Valid types are smallint, integer,
+                // bigint — the same set CREATE SEQUENCE accepts — so the universe
+                // of legal transitions is closed. PG enforces last_value range at
+                // apply time when shrinking; that's the desired behavior because
+                // the previous Drop+Create path silently reset last_value to 1
+                // (data-loss bug, see Sentry SUPABASE-API-7RS).
+                if (mainSequence.data_type !== branchSequence.data_type) {
+                    options.push("AS", branchSequence.data_type);
+                }
                 if (mainSequence.increment !== branchSequence.increment) {
                     options.push("INCREMENT BY", String(branchSequence.increment));
                 }