@supabase/pg-delta 0.0.0 → 1.0.0-alpha.0

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

@@ -0,0 +1,426 @@
+import z from "zod";
+import { BasePgModel, columnPropsSchema, normalizeColumns, } from "../base.model.js";
+import { normalizePrivileges } from "../base.privilege.js";
+import { privilegePropsSchema, } from "../base.privilege-diff.js";
+const RelationPersistenceSchema = z.enum([
+    "p", // permanent
+    "u", // unlogged
+    "t", // temporary
+]);
+export const ReplicaIdentitySchema = z.enum([
+    "d", // DEFAULT (use default key)
+    "n", // NOTHING (no replica identity)
+    "f", // FULL (all columns)
+    "i", // INDEX (specific index)
+]);
+const ForeignKeyActionSchema = z.enum([
+    "a", // NO ACTION
+    "r", // RESTRICT
+    "c", // CASCADE
+    "n", // SET NULL
+    "d", // SET DEFAULT
+]);
+const ForeignKeyMatchTypeSchema = z.enum([
+    "f", // FULL
+    "p", // PARTIAL
+    "s", // SIMPLE
+    "u", // UNSPECIFIED (default)
+]);
+const tableConstraintPropsSchema = z.object({
+    name: z.string(),
+    constraint_type: z.enum([
+        "c", // CHECK constraint
+        "f", // FOREIGN KEY constraint
+        "p", // PRIMARY KEY constraint
+        "u", // UNIQUE constraint
+        "x", // EXCLUDE constraint
+    ]),
+    deferrable: z.boolean(),
+    initially_deferred: z.boolean(),
+    validated: z.boolean(),
+    is_local: z.boolean(),
+    no_inherit: z.boolean(),
+    is_partition_clone: z.boolean(),
+    parent_constraint_schema: z.string().nullable(),
+    parent_constraint_name: z.string().nullable(),
+    parent_table_schema: z.string().nullable(),
+    parent_table_name: z.string().nullable(),
+    key_columns: z.array(z.string()),
+    foreign_key_columns: z.array(z.string()).nullable(),
+    foreign_key_table: z.string().nullable(),
+    foreign_key_schema: z.string().nullable(),
+    foreign_key_table_is_partition: z.boolean().nullable(),
+    foreign_key_parent_schema: z.string().nullable(),
+    foreign_key_parent_table: z.string().nullable(),
+    foreign_key_effective_schema: z.string().nullable(),
+    foreign_key_effective_table: z.string().nullable(),
+    on_update: ForeignKeyActionSchema.nullable(),
+    on_delete: ForeignKeyActionSchema.nullable(),
+    match_type: ForeignKeyMatchTypeSchema.nullable(),
+    check_expression: z.string().nullable(),
+    owner: z.string(),
+    definition: z.string(),
+    comment: z.string().nullable().optional(),
+});
+const tablePropsSchema = z.object({
+    schema: z.string(),
+    name: z.string(),
+    persistence: RelationPersistenceSchema,
+    row_security: z.boolean(),
+    force_row_security: z.boolean(),
+    has_indexes: z.boolean(),
+    has_rules: z.boolean(),
+    has_triggers: z.boolean(),
+    has_subclasses: z.boolean(),
+    is_populated: z.boolean(),
+    replica_identity: ReplicaIdentitySchema,
+    is_partition: z.boolean(),
+    options: z.array(z.string()).nullable(),
+    partition_bound: z.string().nullable(),
+    partition_by: z.string().nullable(),
+    owner: z.string(),
+    comment: z.string().nullable().optional(),
+    parent_schema: z.string().nullable(),
+    parent_name: z.string().nullable(),
+    columns: z.array(columnPropsSchema),
+    constraints: z.array(tableConstraintPropsSchema).optional(),
+    privileges: z.array(privilegePropsSchema),
+});
+export class Table extends BasePgModel {
+    schema;
+    name;
+    persistence;
+    row_security;
+    force_row_security;
+    has_indexes;
+    has_rules;
+    has_triggers;
+    has_subclasses;
+    is_populated;
+    replica_identity;
+    is_partition;
+    options;
+    partition_bound;
+    partition_by;
+    owner;
+    comment;
+    parent_schema;
+    parent_name;
+    columns;
+    constraints;
+    privileges;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.schema = props.schema;
+        this.name = props.name;
+        // Data fields
+        this.persistence = props.persistence;
+        this.row_security = props.row_security;
+        this.force_row_security = props.force_row_security;
+        this.has_indexes = props.has_indexes;
+        this.has_rules = props.has_rules;
+        this.has_triggers = props.has_triggers;
+        this.has_subclasses = props.has_subclasses;
+        this.is_populated = props.is_populated;
+        this.replica_identity = props.replica_identity;
+        this.is_partition = props.is_partition;
+        this.options = props.options;
+        this.partition_bound = props.partition_bound;
+        this.partition_by = props.partition_by;
+        this.owner = props.owner;
+        this.comment = props.comment;
+        this.parent_schema = props.parent_schema;
+        this.parent_name = props.parent_name;
+        this.columns = props.columns;
+        this.constraints = props.constraints ?? [];
+        this.privileges = props.privileges;
+    }
+    get stableId() {
+        return `table:${this.schema}.${this.name}`;
+    }
+    get identityFields() {
+        return {
+            schema: this.schema,
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            // Only include fields that can be managed via ALTER safely
+            persistence: this.persistence,
+            row_security: this.row_security,
+            force_row_security: this.force_row_security,
+            replica_identity: this.replica_identity,
+            options: this.options,
+            // Partition membership can be altered via ATTACH/DETACH
+            parent_schema: this.parent_schema,
+            parent_name: this.parent_name,
+            partition_bound: this.partition_bound,
+            owner: this.owner,
+            comment: this.comment,
+            columns: this.columns,
+            constraints: this.constraints,
+            privileges: this.privileges,
+        };
+    }
+    stableSnapshot() {
+        const normalizeConstraints = () => [...this.constraints].sort((a, b) => {
+            const nameA = a.name ?? "";
+            const nameB = b.name ?? "";
+            return nameA.localeCompare(nameB);
+        });
+        return {
+            identity: this.identityFields,
+            data: {
+                ...this.dataFields,
+                columns: normalizeColumns(this.columns),
+                options: this.options ? [...this.options].sort() : this.options,
+                constraints: normalizeConstraints(),
+                privileges: normalizePrivileges(this.privileges),
+            },
+        };
+    }
+}
+export async function extractTables(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const tableRows = await sql `
+with extension_oids as (
+  select objid
+  from pg_depend d
+  where d.refclassid = 'pg_extension'::regclass
+    and d.classid = 'pg_class'::regclass
+), tables as (
+  select
+    c.relnamespace::regnamespace::text as schema,
+    quote_ident(c.relname) as name,
+    c.relpersistence as persistence,
+    c.relrowsecurity as row_security,
+    c.relforcerowsecurity as force_row_security,
+    c.relhasindex as has_indexes,
+    c.relhasrules as has_rules,
+    c.relhastriggers as has_triggers,
+    c.relhassubclass as has_subclasses,
+    c.relispopulated as is_populated,
+    c.relreplident as replica_identity,
+    c.relispartition as is_partition,
+    c.reloptions as options,
+    pg_get_expr(c.relpartbound, c.oid) as partition_bound,
+    pg_get_partkeydef(c.oid) as partition_by,
+    c.relowner::regrole::text as owner,
+    c_parent.relnamespace::regnamespace as parent_schema,
+    quote_ident(c_parent.relname) as parent_name,
+    c.oid as oid
+  from
+    pg_class c
+    left join extension_oids e1 on c.oid = e1.objid
+    left join pg_inherits i on i.inhrelid = c.oid
+    left join pg_class c_parent on i.inhparent = c_parent.oid
+  where
+    c.relkind in ('r', 'p')
+    and not c.relnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+    and e1.objid is null
+)
+select
+  t.schema,
+  t.name,
+  t.persistence,
+  t.row_security,
+  t.force_row_security,
+  t.has_indexes,
+  t.has_rules,
+  t.has_triggers,
+  t.has_subclasses,
+  t.is_populated,
+  t.replica_identity,
+  t.is_partition,
+  t.options,
+  t.partition_bound,
+  t.partition_by,
+  t.owner,
+  obj_description(t.oid, 'pg_class') as comment,
+  t.parent_schema,
+  t.parent_name,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object(
+          'name', quote_ident(c.conname),
+          'constraint_type', c.contype,
+          'deferrable', c.condeferrable,
+          'initially_deferred', c.condeferred,
+          'validated', c.convalidated,
+          'is_local', c.conislocal,
+          'no_inherit', c.connoinherit,
+
+          -- NEW: propagated-to-partition tagging (PG15+)
+          'is_partition_clone', (c.conparentid <> 0::oid),
+          'parent_constraint_schema', case when c.conparentid <> 0::oid then pc.connamespace::regnamespace::text end,
+          'parent_constraint_name',   case when c.conparentid <> 0::oid then quote_ident(pc.conname) end,
+          'parent_table_schema',      case when c.conparentid <> 0::oid then pc_rel.relnamespace::regnamespace::text end,
+          'parent_table_name',        case when c.conparentid <> 0::oid then quote_ident(pc_rel.relname) end,
+
+          'key_columns',
+            case
+              when c.conkey is not null then (
+                select json_agg(quote_ident(att.attname) order by pk.ordinality)
+                from unnest(c.conkey) with ordinality as pk(attnum, ordinality)
+                join pg_attribute att
+                  on att.attrelid = c.conrelid
+                and att.attnum = pk.attnum
+                and att.attisdropped = false
+              )
+              else '[]'::json
+            end,
+
+          'foreign_key_columns',
+            case
+              when c.contype = 'f' then (
+                select json_agg(quote_ident(att.attname) order by fk.ordinality)
+                from unnest(c.confkey) with ordinality as fk(attnum, ordinality)
+                join pg_attribute att
+                  on att.attrelid = c.confrelid
+                and att.attnum = fk.attnum
+                and att.attisdropped = false
+              )
+              else null
+            end,
+
+          -- existing FK target
+          'foreign_key_table',  quote_ident(ftc.relname),
+          'foreign_key_schema', ftc.relnamespace::regnamespace::text,
+
+          -- NEW: if FK points at a *partition*, expose its parent + an "effective" target
+          'foreign_key_table_is_partition',
+            case when c.contype = 'f' then coalesce(ftc.relispartition, false) else null end,
+          'foreign_key_parent_schema',
+            case when c.contype = 'f' and ftc.relispartition then ftc_parent.relnamespace::regnamespace::text else null end,
+          'foreign_key_parent_table',
+            case when c.contype = 'f' and ftc.relispartition then quote_ident(ftc_parent.relname) else null end,
+          'foreign_key_effective_schema',
+            case
+              when c.contype <> 'f' then null
+              when ftc.relispartition then ftc_parent.relnamespace::regnamespace::text
+              else ftc.relnamespace::regnamespace::text
+            end,
+          'foreign_key_effective_table',
+            case
+              when c.contype <> 'f' then null
+              when ftc.relispartition then quote_ident(ftc_parent.relname)
+              else quote_ident(ftc.relname)
+            end,
+
+          'on_update',  case when c.contype = 'f' then c.confupdtype   else null end,
+          'on_delete',  case when c.contype = 'f' then c.confdeltype   else null end,
+          'match_type', case when c.contype = 'f' then c.confmatchtype else null end,
+
+          'check_expression', pg_get_expr(c.conbin, c.conrelid),
+          'owner', t.owner,
+          'definition', pg_get_constraintdef(c.oid, true),
+          'comment', obj_description(c.oid, 'pg_constraint')
+        )
+        order by c.conname
+      )
+      from pg_catalog.pg_constraint c
+
+      -- NEW: parent constraint/table lookup (for propagated constraints)
+      left join pg_catalog.pg_constraint pc on pc.oid = c.conparentid
+      left join pg_catalog.pg_class pc_rel on pc_rel.oid = pc.conrelid
+
+      -- FK referenced table + parent table if it’s a partition
+      left join pg_catalog.pg_class ftc on ftc.oid = c.confrelid
+      left join pg_catalog.pg_inherits fi on fi.inhrelid = ftc.oid
+      left join pg_catalog.pg_class ftc_parent on ftc_parent.oid = fi.inhparent
+
+      left join pg_depend de
+        on de.classid = 'pg_constraint'::regclass
+      and de.objid = c.oid
+      and de.refclassid = 'pg_extension'::regclass
+
+      where c.conrelid = t.oid
+        and not c.connamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+        and de.objid is null
+    ),
+    '[]'
+  ) as constraints,
+  coalesce(json_agg(
+    case when a.attname is not null then
+      json_build_object(
+        'name', quote_ident(a.attname),
+        'position', a.attnum,
+        'data_type', a.atttypid::regtype::text,
+        'data_type_str', format_type(a.atttypid, a.atttypmod),
+        'is_custom_type', ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema'),
+        'custom_type_type', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then ty.typtype else null end,
+        'custom_type_category', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then ty.typcategory else null end,
+        'custom_type_schema', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then ty.typnamespace::regnamespace else null end,
+        'custom_type_name', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then quote_ident(ty.typname) else null end,
+        'not_null', a.attnotnull,
+        'is_identity', a.attidentity != '',
+        'is_identity_always', a.attidentity = 'a',
+        'is_generated', a.attgenerated != '',
+        'collation', (
+          select quote_ident(c2.collname)
+          from pg_collation c2, pg_type t2
+          where c2.oid = a.attcollation
+            and t2.oid = a.atttypid
+            and a.attcollation <> t2.typcollation
+        ),
+        'default', pg_get_expr(ad.adbin, ad.adrelid),
+        'comment', col_description(a.attrelid, a.attnum)
+      )
+    end
+    order by a.attnum
+  ) filter (where a.attname is not null), '[]') as columns,
+  coalesce((
+    select json_agg(
+            json_build_object(
+              'grantee', case when grp.grantee = 0 then 'PUBLIC' else grp.grantee::regrole::text end,
+              'privilege', grp.privilege_type,
+              'grantable', grp.is_grantable,
+              'columns', case when grp.cols is not null and array_length(grp.cols,1) > 0
+                              then grp.cols
+                              else null end
+            )
+            order by grp.grantee, grp.privilege_type
+          )
+    from (
+      select
+        x.grantee,
+        x.privilege_type,
+        bool_or(x.is_grantable) as is_grantable,
+        array_agg(quote_ident(src.attname) order by src.attname)
+          filter (where src.attname is not null) as cols
+      from (
+        -- one row for object ACL + one row per column ACL
+        select null::name as attname, t.oid as relacl_oid, (
+          select c_rel.relacl from pg_class c_rel where c_rel.oid = t.oid
+        ) as acl
+        union all
+        select a2.attname, t.oid as relacl_oid, a2.attacl
+        from pg_attribute a2
+        where a2.attrelid = t.oid
+          and a2.attnum > 0
+          and not a2.attisdropped
+          and a2.attacl is not null
+      ) as src
+      join lateral aclexplode(src.acl) as x(grantor, grantee, privilege_type, is_grantable) on true
+      group by x.grantee, x.privilege_type
+    ) as grp
+  ), '[]') as privileges
+from
+  tables t
+  left join pg_attribute a on a.attrelid = t.oid and a.attnum > 0 and not a.attisdropped
+  left join pg_attrdef ad on a.attrelid = ad.adrelid and a.attnum = ad.adnum
+  left join pg_type ty on ty.oid = a.atttypid
+group by
+  t.oid, t.schema, t.name, t.persistence, t.row_security, t.force_row_security, t.has_indexes, t.has_rules, t.has_triggers, t.has_subclasses, t.is_populated, t.replica_identity, t.is_partition, t.options, t.partition_bound, t.partition_by, t.owner, t.parent_schema, t.parent_name
+order by
+  t.schema, t.name;
+    `;
+        // Validate and parse each row using the Zod schema
+        const validatedRows = tableRows.map((row) => tablePropsSchema.parse(row));
+        return validatedRows.map((row) => new Table(row));
+    });
+}

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

@@ -0,0 +1,29 @@
+import type { TableLikeObject } from "../../base.model.ts";
+import type { Trigger } from "../trigger.model.ts";
+import { AlterTriggerChange } from "./trigger.base.ts";
+/**
+ * Alter a trigger.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-altertrigger.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER TRIGGER name ON table_name RENAME TO new_name
+ * ```
+ */
+export type AlterTrigger = ReplaceTrigger;
+/**
+ * Replace a trigger by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER TRIGGER change.
+ */
+export declare class ReplaceTrigger extends AlterTriggerChange {
+    readonly trigger: Trigger;
+    readonly indexableObject?: TableLikeObject;
+    readonly scope: "object";
+    constructor(props: {
+        trigger: Trigger;
+        indexableObject?: TableLikeObject;
+    });
+    get requires(): `trigger:${string}`[];
+    serialize(): string;
+}

package/dist/core/objects/trigger/changes/trigger.alter.js

@@ -0,0 +1,27 @@
+import { AlterTriggerChange } from "./trigger.base.js";
+import { CreateTrigger } from "./trigger.create.js";
+/**
+ * Replace a trigger by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER TRIGGER change.
+ */
+export class ReplaceTrigger extends AlterTriggerChange {
+    trigger;
+    indexableObject;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.trigger = props.trigger;
+        this.indexableObject = props.indexableObject;
+    }
+    get requires() {
+        return [this.trigger.stableId];
+    }
+    serialize() {
+        const createChange = new CreateTrigger({
+            trigger: this.trigger,
+            indexableObject: this.indexableObject,
+            orReplace: true,
+        });
+        return createChange.serialize();
+    }
+}

package/dist/core/objects/trigger/changes/trigger.base.d.ts

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Trigger } from "../trigger.model.ts";
+declare abstract class BaseTriggerChange extends BaseChange {
+    abstract readonly trigger: Trigger;
+    abstract readonly scope: "object" | "comment";
+    readonly objectType: "trigger";
+}
+export declare abstract class CreateTriggerChange extends BaseTriggerChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterTriggerChange extends BaseTriggerChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropTriggerChange extends BaseTriggerChange {
+    readonly operation: "drop";
+}
+export {};

package/dist/core/objects/trigger/changes/trigger.base.js

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../base.change.js";
+class BaseTriggerChange extends BaseChange {
+    objectType = "trigger";
+}
+export class CreateTriggerChange extends BaseTriggerChange {
+    operation = "create";
+}
+export class AlterTriggerChange extends BaseTriggerChange {
+    operation = "alter";
+}
+export class DropTriggerChange extends BaseTriggerChange {
+    operation = "drop";
+}

package/dist/core/objects/trigger/changes/trigger.comment.d.ts

@@ -0,0 +1,23 @@
+import type { Trigger } from "../trigger.model.ts";
+import { CreateTriggerChange, DropTriggerChange } from "./trigger.base.ts";
+export type CommentTrigger = CreateCommentOnTrigger | DropCommentOnTrigger;
+export declare class CreateCommentOnTrigger extends CreateTriggerChange {
+    readonly trigger: Trigger;
+    readonly scope: "comment";
+    constructor(props: {
+        trigger: Trigger;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `trigger:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnTrigger extends DropTriggerChange {
+    readonly trigger: Trigger;
+    readonly scope: "comment";
+    constructor(props: {
+        trigger: Trigger;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `trigger:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/trigger/changes/trigger.comment.js

@@ -0,0 +1,51 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateTriggerChange, DropTriggerChange } from "./trigger.base.js";
+export class CreateCommentOnTrigger extends CreateTriggerChange {
+    trigger;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.trigger = props.trigger;
+    }
+    get creates() {
+        return [stableId.comment(this.trigger.stableId)];
+    }
+    get requires() {
+        return [this.trigger.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON TRIGGER",
+            this.trigger.name,
+            "ON",
+            `${this.trigger.schema}.${this.trigger.table_name}`,
+            "IS",
+            // biome-ignore lint/style/noNonNullAssertion: trigger comment is not nullable in this case
+            quoteLiteral(this.trigger.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnTrigger extends DropTriggerChange {
+    trigger;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.trigger = props.trigger;
+    }
+    get drops() {
+        return [stableId.comment(this.trigger.stableId)];
+    }
+    get requires() {
+        return [stableId.comment(this.trigger.stableId), this.trigger.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON TRIGGER",
+            this.trigger.name,
+            "ON",
+            `${this.trigger.schema}.${this.trigger.table_name}`,
+            "IS NULL",
+        ].join(" ");
+    }
+}

package/dist/core/objects/trigger/changes/trigger.create.d.ts

@@ -0,0 +1,41 @@
+import type { TableLikeObject } from "../../base.model.ts";
+import type { Trigger } from "../trigger.model.ts";
+import { CreateTriggerChange } from "./trigger.base.ts";
+/**
+ * Create a trigger.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createtrigger.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE [ OR REPLACE ] [ CONSTRAINT ] TRIGGER name { BEFORE | AFTER | INSTEAD OF } { event [ OR ... ] }
+ *     ON table_name
+ *     [ FROM referenced_table_name ]
+ *     [ NOT DEFERRABLE | [ DEFERRABLE ] [ INITIALLY IMMEDIATE | INITIALLY DEFERRED ] ]
+ *     [ REFERENCING { { OLD | NEW } TABLE [ AS ] transition_relation_name } [ ... ] ]
+ *     [ FOR [ EACH ] { ROW | STATEMENT } ]
+ *     [ WHEN ( condition ) ]
+ *     EXECUTE { FUNCTION | PROCEDURE } function_name ( arguments )
+ *
+ * where event can be one of:
+ *
+ *     INSERT
+ *     UPDATE [ OF column_name [, ... ] ]
+ *     DELETE
+ *     TRUNCATE
+ * ```
+ */
+export declare class CreateTrigger extends CreateTriggerChange {
+    readonly trigger: Trigger;
+    readonly indexableObject?: TableLikeObject;
+    readonly orReplace?: boolean;
+    readonly scope: "object";
+    constructor(props: {
+        trigger: Trigger;
+        indexableObject?: TableLikeObject;
+        orReplace?: boolean;
+    });
+    get creates(): `trigger:${string}`[];
+    get requires(): string[];
+    serialize(): string;
+}