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

package/dist/core/objects/type/composite-type/composite-type.model.js

@@ -0,0 +1,223 @@
+import z from "zod";
+import { BasePgModel, columnPropsSchema, } from "../../base.model.js";
+import { privilegePropsSchema, } from "../../base.privilege-diff.js";
+import { ReplicaIdentitySchema } from "../../table/table.model.js";
+const compositeTypePropsSchema = z.object({
+    schema: z.string(),
+    name: z.string(),
+    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(),
+    owner: z.string(),
+    comment: z.string().nullable(),
+    columns: z.array(columnPropsSchema),
+    privileges: z.array(privilegePropsSchema),
+});
+export class CompositeType extends BasePgModel {
+    schema;
+    name;
+    row_security;
+    force_row_security;
+    has_indexes;
+    has_rules;
+    has_triggers;
+    has_subclasses;
+    is_populated;
+    replica_identity;
+    is_partition;
+    options;
+    partition_bound;
+    owner;
+    comment;
+    columns;
+    privileges;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.schema = props.schema;
+        this.name = props.name;
+        // Data fields
+        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.owner = props.owner;
+        this.comment = props.comment;
+        this.columns = props.columns;
+        this.privileges = props.privileges;
+    }
+    get stableId() {
+        return `type:${this.schema}.${this.name}`;
+    }
+    get identityFields() {
+        return {
+            schema: this.schema,
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            row_security: this.row_security,
+            force_row_security: this.force_row_security,
+            has_indexes: this.has_indexes,
+            has_rules: this.has_rules,
+            has_triggers: this.has_triggers,
+            has_subclasses: this.has_subclasses,
+            is_populated: this.is_populated,
+            replica_identity: this.replica_identity,
+            is_partition: this.is_partition,
+            options: this.options,
+            partition_bound: this.partition_bound,
+            owner: this.owner,
+            comment: this.comment,
+            columns: this.columns,
+            privileges: this.privileges,
+        };
+    }
+    stableSnapshot() {
+        const normalizeColumns = () => [...this.columns]
+            .map((col) => {
+            const { position: _pos, ...rest } = col;
+            return rest;
+        })
+            .sort((a, b) => {
+            const nameA = a.name ?? "";
+            const nameB = b.name ?? "";
+            return nameA.localeCompare(nameB);
+        });
+        return {
+            identity: this.identityFields,
+            data: {
+                ...this.dataFields,
+                columns: normalizeColumns(),
+            },
+        };
+    }
+}
+export async function extractCompositeTypes(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const compositeTypeRows = await sql `
+      WITH extension_oids AS (
+        SELECT objid
+        FROM pg_depend d
+        WHERE d.refclassid = 'pg_extension'::regclass
+          AND d.classid    = 'pg_type'::regclass
+      ),
+      composite_types AS (
+        SELECT
+          c.relnamespace::regnamespace::text AS schema,
+          quote_ident(c.relname)              AS name,
+          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,
+          c.relowner::regrole::text           AS owner,
+          obj_description(c.reltype, 'pg_type') AS comment,
+          c.relacl                            AS relacl,    -- used by privileges LATERAL
+          c.oid                                AS oid
+        FROM pg_catalog.pg_class c
+        LEFT JOIN extension_oids e ON c.reltype = e.objid
+        WHERE NOT c.relnamespace::regnamespace::text LIKE ANY (ARRAY['pg\\_%', 'information\\_schema'])
+          AND e.objid IS NULL
+          AND c.relkind = 'c'
+      )
+      SELECT
+        ct.schema,
+        ct.name,
+        ct.row_security,
+        ct.force_row_security,
+        ct.has_indexes,
+        ct.has_rules,
+        ct.has_triggers,
+        ct.has_subclasses,
+        ct.is_populated,
+        ct.replica_identity,
+        ct.is_partition,
+        ct.options,
+        ct.partition_bound,
+        ct.owner,
+        ct.comment,
+        COALESCE(priv.privileges, '[]') AS privileges,
+        COALESCE(cols.columns, '[]')    AS columns
+      FROM composite_types ct
+
+      -- privileges as a per-row LATERAL subquery
+      LEFT JOIN LATERAL (
+        SELECT json_agg(
+                json_build_object(
+                  'grantee',   CASE WHEN x.grantee = 0 THEN 'PUBLIC' ELSE x.grantee::regrole::text END,
+                  'privilege', x.privilege_type,
+                  'grantable', x.is_grantable
+                )
+                ORDER BY x.grantee, x.privilege_type
+              ) AS privileges
+        FROM LATERAL aclexplode(ct.relacl) AS x(grantor, grantee, privilege_type, is_grantable)
+      ) priv ON TRUE
+
+      -- columns as a per-row LATERAL subquery (so no GROUP BY needed)
+      LEFT JOIN LATERAL (
+        SELECT json_agg(
+                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)
+                )
+                ORDER BY a.attnum
+              ) AS columns
+        FROM pg_attribute a
+        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
+        WHERE a.attrelid = ct.oid
+          AND a.attnum > 0
+          AND NOT a.attisdropped
+      ) cols ON TRUE
+
+      ORDER BY ct.schema, ct.name;
+    `;
+        // Validate and parse each row using the Zod schema
+        const validatedRows = compositeTypeRows.map((row) => compositeTypePropsSchema.parse(row));
+        return validatedRows.map((row) => new CompositeType(row));
+    });
+}

package/dist/core/objects/type/enum/changes/enum.alter.d.ts

@@ -0,0 +1,52 @@
+import type { Enum } from "../enum.model.ts";
+import { AlterEnumChange } from "./enum.base.ts";
+/**
+ * Alter an enum.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-altertype.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER TYPE name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ * ALTER TYPE name RENAME TO new_name
+ * ALTER TYPE name ADD VALUE [ IF NOT EXISTS ] new_enum_value [ { BEFORE | AFTER } neighbor_enum_value ]
+ * ALTER TYPE name RENAME VALUE existing_enum_value TO new_enum_value
+ * ```
+ */
+export type AlterEnum = AlterEnumAddValue | AlterEnumChangeOwner;
+/**
+ * ALTER TYPE ... OWNER TO ...
+ */
+export declare class AlterEnumChangeOwner extends AlterEnumChange {
+    readonly enum: Enum;
+    readonly owner: string;
+    readonly scope: "object";
+    constructor(props: {
+        enum: Enum;
+        owner: string;
+    });
+    get requires(): `type:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER TYPE ... ADD VALUE ...
+ */
+export declare class AlterEnumAddValue extends AlterEnumChange {
+    readonly enum: Enum;
+    readonly newValue: string;
+    readonly position?: {
+        before?: string;
+        after?: string;
+    };
+    readonly scope: "object";
+    constructor(props: {
+        enum: Enum;
+        newValue: string;
+        position?: {
+            before?: string;
+            after?: string;
+        };
+    });
+    get requires(): `type:${string}`[];
+    serialize(): string;
+}

package/dist/core/objects/type/enum/changes/enum.alter.js

@@ -0,0 +1,60 @@
+import { quoteLiteral } from "../../../base.change.js";
+import { AlterEnumChange } from "./enum.base.js";
+/**
+ * ALTER TYPE ... OWNER TO ...
+ */
+export class AlterEnumChangeOwner extends AlterEnumChange {
+    enum;
+    owner;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.enum = props.enum;
+        this.owner = props.owner;
+    }
+    get requires() {
+        return [this.enum.stableId];
+    }
+    serialize() {
+        return [
+            "ALTER TYPE",
+            `${this.enum.schema}.${this.enum.name}`,
+            "OWNER TO",
+            this.owner,
+        ].join(" ");
+    }
+}
+/**
+ * ALTER TYPE ... ADD VALUE ...
+ */
+export class AlterEnumAddValue extends AlterEnumChange {
+    enum;
+    newValue;
+    position;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.enum = props.enum;
+        this.newValue = props.newValue;
+        this.position = props.position;
+    }
+    get requires() {
+        return [this.enum.stableId];
+    }
+    serialize() {
+        const parts = [
+            "ALTER TYPE",
+            `${this.enum.schema}.${this.enum.name}`,
+            "ADD VALUE",
+            quoteLiteral(this.newValue),
+        ];
+        if (this.position?.before) {
+            parts.push("BEFORE", quoteLiteral(this.position.before));
+        }
+        else if (this.position?.after) {
+            parts.push("AFTER", quoteLiteral(this.position.after));
+        }
+        return parts.join(" ");
+    }
+}
+// NOTE: ReplaceEnum removed. Complex enum changes should be handled in diff with Drop + Create when needed.

package/dist/core/objects/type/enum/changes/enum.base.d.ts

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../../base.change.ts";
+import type { Enum } from "../enum.model.ts";
+declare abstract class BaseEnumChange extends BaseChange {
+    abstract readonly enum: Enum;
+    abstract readonly scope: "object" | "comment" | "privilege";
+    readonly objectType: "enum";
+}
+export declare abstract class CreateEnumChange extends BaseEnumChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterEnumChange extends BaseEnumChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropEnumChange extends BaseEnumChange {
+    readonly operation: "drop";
+}
+export {};

package/dist/core/objects/type/enum/changes/enum.base.js

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../../base.change.js";
+class BaseEnumChange extends BaseChange {
+    objectType = "enum";
+}
+export class CreateEnumChange extends BaseEnumChange {
+    operation = "create";
+}
+export class AlterEnumChange extends BaseEnumChange {
+    operation = "alter";
+}
+export class DropEnumChange extends BaseEnumChange {
+    operation = "drop";
+}

package/dist/core/objects/type/enum/changes/enum.comment.d.ts

@@ -0,0 +1,26 @@
+import type { Enum } from "../enum.model.ts";
+import { CreateEnumChange, DropEnumChange } from "./enum.base.ts";
+/**
+ * Create/drop comments on enum types.
+ */
+export type CommentEnum = CreateCommentOnEnum | DropCommentOnEnum;
+export declare class CreateCommentOnEnum extends CreateEnumChange {
+    readonly enum: Enum;
+    readonly scope: "comment";
+    constructor(props: {
+        enum: Enum;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `type:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnEnum extends DropEnumChange {
+    readonly enum: Enum;
+    readonly scope: "comment";
+    constructor(props: {
+        enum: Enum;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `type:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/type/enum/changes/enum.comment.js

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

package/dist/core/objects/type/enum/changes/enum.create.d.ts

@@ -0,0 +1,22 @@
+import type { Enum } from "../enum.model.ts";
+import { CreateEnumChange } from "./enum.base.ts";
+/**
+ * Create an enum.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createtype.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE TYPE name AS ENUM ( [ label [, ...] ] )
+ * ```
+ */
+export declare class CreateEnum extends CreateEnumChange {
+    readonly enum: Enum;
+    readonly scope: "object";
+    constructor(props: {
+        enum: Enum;
+    });
+    get creates(): `type:${string}`[];
+    get requires(): string[];
+    serialize(): string;
+}

package/dist/core/objects/type/enum/changes/enum.create.js

@@ -0,0 +1,43 @@
+import { quoteLiteral } from "../../../base.change.js";
+import { stableId } from "../../../utils.js";
+import { CreateEnumChange } from "./enum.base.js";
+/**
+ * Create an enum.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createtype.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE TYPE name AS ENUM ( [ label [, ...] ] )
+ * ```
+ */
+export class CreateEnum extends CreateEnumChange {
+    enum;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.enum = props.enum;
+    }
+    get creates() {
+        return [this.enum.stableId];
+    }
+    get requires() {
+        const dependencies = new Set();
+        // Schema dependency
+        dependencies.add(stableId.schema(this.enum.schema));
+        // Owner dependency
+        dependencies.add(stableId.role(this.enum.owner));
+        return Array.from(dependencies);
+    }
+    serialize() {
+        const parts = ["CREATE TYPE"];
+        // Add schema and name
+        parts.push(`${this.enum.schema}.${this.enum.name}`);
+        // Add AS ENUM
+        parts.push("AS ENUM");
+        // Add labels
+        const labels = this.enum.labels.map((label) => quoteLiteral(label.label));
+        parts.push(`(${labels.join(", ")})`);
+        return parts.join(" ");
+    }
+}

package/dist/core/objects/type/enum/changes/enum.drop.d.ts

@@ -0,0 +1,22 @@
+import type { Enum } from "../enum.model.ts";
+import { DropEnumChange } from "./enum.base.ts";
+/**
+ * Drop an enum.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-droptype.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP TYPE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export declare class DropEnum extends DropEnumChange {
+    readonly enum: Enum;
+    readonly scope: "object";
+    constructor(props: {
+        enum: Enum;
+    });
+    get drops(): `type:${string}`[];
+    get requires(): `type:${string}`[];
+    serialize(): string;
+}

package/dist/core/objects/type/enum/changes/enum.drop.js

@@ -0,0 +1,28 @@
+import { DropEnumChange } from "./enum.base.js";
+/**
+ * Drop an enum.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-droptype.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP TYPE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropEnum extends DropEnumChange {
+    enum;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.enum = props.enum;
+    }
+    get drops() {
+        return [this.enum.stableId];
+    }
+    get requires() {
+        return [this.enum.stableId];
+    }
+    serialize() {
+        return ["DROP TYPE", `${this.enum.schema}.${this.enum.name}`].join(" ");
+    }
+}

package/dist/core/objects/type/enum/changes/enum.privilege.d.ts

@@ -0,0 +1,97 @@
+import type { Enum } from "../enum.model.ts";
+import { AlterEnumChange } from "./enum.base.ts";
+export type EnumPrivilege = GrantEnumPrivileges | RevokeEnumPrivileges | RevokeGrantOptionEnumPrivileges;
+/**
+ * Grant privileges on an enum type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { USAGE | ALL [ PRIVILEGES ] }
+ *    ON TYPE type_name [, ...]
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export declare class GrantEnumPrivileges extends AlterEnumChange {
+    readonly enum: Enum;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        enum: Enum;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        version?: number;
+    });
+    get creates(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`role:${string}` | `type:${string}`)[];
+    serialize(): string;
+}
+/**
+ * Revoke privileges on an enum type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { USAGE | ALL [ PRIVILEGES ] }
+ *     ON TYPE type_name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export declare class RevokeEnumPrivileges extends AlterEnumChange {
+    readonly enum: Enum;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        enum: Enum;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        version?: number;
+    });
+    get drops(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `type:${string}`)[];
+    serialize(): string;
+}
+/**
+ * Revoke grant option for privileges on an enum type.
+ *
+ * This removes the ability to grant the privilege to others, but keeps the privilege itself.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ */
+export declare class RevokeGrantOptionEnumPrivileges extends AlterEnumChange {
+    readonly enum: Enum;
+    readonly grantee: string;
+    readonly privilegeNames: string[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        enum: Enum;
+        grantee: string;
+        privilegeNames: string[];
+        version?: number;
+    });
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `type:${string}`)[];
+    serialize(): string;
+}