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

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

@@ -0,0 +1,67 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+/**
+ * All properties exposed by CREATE COLLATION statement are included in diff output.
+ * https://www.postgresql.org/docs/current/sql-createcollation.html
+ *
+ * ALTER COLLATION statement can only be generated for a subset of properties:
+ *  - version, name, owner, schema
+ * https://www.postgresql.org/docs/current/sql-altercollation.html
+ *
+ * Other properties require dropping and creating a new collation.
+ */
+declare const collationPropsSchema: z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+    provider: z.ZodEnum<{
+        i: "i";
+        b: "b";
+        d: "d";
+        c: "c";
+    }>;
+    is_deterministic: z.ZodBoolean;
+    encoding: z.ZodNumber;
+    collate: z.ZodString;
+    ctype: z.ZodString;
+    locale: z.ZodNullable<z.ZodString>;
+    icu_rules: z.ZodNullable<z.ZodString>;
+    version: z.ZodNullable<z.ZodString>;
+    owner: z.ZodString;
+    comment: z.ZodNullable<z.ZodString>;
+}, z.z.core.$strip>;
+export type CollationProps = z.infer<typeof collationPropsSchema>;
+export declare class Collation extends BasePgModel {
+    readonly schema: CollationProps["schema"];
+    readonly name: CollationProps["name"];
+    readonly provider: CollationProps["provider"];
+    readonly is_deterministic: CollationProps["is_deterministic"];
+    readonly encoding: CollationProps["encoding"];
+    readonly collate: CollationProps["collate"];
+    readonly ctype: CollationProps["ctype"];
+    readonly locale: CollationProps["locale"];
+    readonly icu_rules: CollationProps["icu_rules"];
+    readonly version: CollationProps["version"];
+    readonly owner: CollationProps["owner"];
+    readonly comment: CollationProps["comment"];
+    constructor(props: CollationProps);
+    get stableId(): `collation:${string}`;
+    get identityFields(): {
+        schema: string;
+        name: string;
+    };
+    get dataFields(): {
+        provider: "i" | "b" | "d" | "c";
+        is_deterministic: boolean;
+        encoding: number;
+        collate: string;
+        ctype: string;
+        locale: string | null;
+        icu_rules: string | null;
+        version: string | null;
+        owner: string;
+        comment: string | null;
+    };
+}
+export declare function extractCollations(sql: Sql): Promise<Collation[]>;
+export {};

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

@@ -0,0 +1,207 @@
+import z from "zod";
+import { extractVersion } from "../../context.js";
+import { BasePgModel } from "../base.model.js";
+/**
+ * Collation provider codes as stored in pg_collation.collprovider
+ */
+const CollationProviderSchema = z.enum([
+    "d", // database default provider (omit PROVIDER clause)
+    "b", // builtin
+    "c", // libc
+    "i", // icu
+]);
+/**
+ * All properties exposed by CREATE COLLATION statement are included in diff output.
+ * https://www.postgresql.org/docs/current/sql-createcollation.html
+ *
+ * ALTER COLLATION statement can only be generated for a subset of properties:
+ *  - version, name, owner, schema
+ * https://www.postgresql.org/docs/current/sql-altercollation.html
+ *
+ * Other properties require dropping and creating a new collation.
+ */
+const collationPropsSchema = z.object({
+    schema: z.string(),
+    name: z.string(),
+    provider: CollationProviderSchema,
+    is_deterministic: z.boolean(),
+    encoding: z.number(),
+    collate: z.string(),
+    ctype: z.string(),
+    locale: z.string().nullable(),
+    icu_rules: z.string().nullable(),
+    version: z.string().nullable(),
+    owner: z.string(),
+    comment: z.string().nullable(),
+});
+export class Collation extends BasePgModel {
+    schema;
+    name;
+    provider;
+    is_deterministic;
+    encoding;
+    collate;
+    ctype;
+    locale;
+    icu_rules;
+    version;
+    owner;
+    comment;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.schema = props.schema;
+        this.name = props.name;
+        // Data fields
+        this.provider = props.provider;
+        this.is_deterministic = props.is_deterministic;
+        this.encoding = props.encoding;
+        this.collate = props.collate;
+        this.ctype = props.ctype;
+        this.locale = props.locale;
+        this.icu_rules = props.icu_rules;
+        this.version = props.version;
+        this.owner = props.owner;
+        this.comment = props.comment;
+    }
+    get stableId() {
+        return `collation:${this.schema}.${this.name}`;
+    }
+    get identityFields() {
+        return {
+            schema: this.schema,
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            provider: this.provider,
+            is_deterministic: this.is_deterministic,
+            encoding: this.encoding,
+            collate: this.collate,
+            ctype: this.ctype,
+            locale: this.locale,
+            icu_rules: this.icu_rules,
+            version: this.version,
+            owner: this.owner,
+            comment: this.comment,
+        };
+    }
+}
+export async function extractCollations(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const version = await extractVersion(sql);
+        const isPostgres17OrGreater = version >= 170000;
+        const isPostgres16OrGreater = version >= 160000;
+        let collations;
+        if (isPostgres17OrGreater) {
+            collations = await sql `
+      with extension_oids as (
+        select
+          objid
+        from
+          pg_depend d
+        where
+          d.refclassid = 'pg_extension'::regclass
+          and d.classid = 'pg_collation'::regclass
+      )
+      select
+        c.collnamespace::regnamespace::text as schema,
+        quote_ident(c.collname) as name,
+        c.collprovider as provider,
+        c.collisdeterministic as is_deterministic,
+        c.collencoding as encoding,
+        c.collcollate as collate,
+        c.collctype as ctype,
+        c.colllocale as locale,
+        c.collicurules as icu_rules,
+        c.collversion as version,
+        c.collowner::regrole::text as owner,
+        obj_description(c.oid, 'pg_collation') as comment
+      from
+        pg_catalog.pg_collation c
+        left outer join extension_oids e on c.oid = e.objid
+        where not c.collnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+        and e.objid is null
+      order by
+        1, 2;
+  `;
+        }
+        else if (isPostgres16OrGreater) {
+            // On postgres 16 there colllocale column was named colliculocale
+            collations = await sql `
+      with extension_oids as (
+        select
+          objid
+        from
+          pg_depend d
+        where
+          d.refclassid = 'pg_extension'::regclass
+          and d.classid = 'pg_collation'::regclass
+      )
+      select
+        c.collnamespace::regnamespace::text as schema,
+        quote_ident(c.collname) as name,
+        c.collprovider as provider,
+        c.collisdeterministic as is_deterministic,
+        c.collencoding as encoding,
+        c.collcollate as collate,
+        c.collctype as ctype,
+        colliculocale as locale,
+        c.collicurules as icu_rules,
+        c.collversion as version,
+        c.collowner::regrole::text as owner,
+        obj_description(c.oid, 'pg_collation') as comment
+      from
+        pg_catalog.pg_collation c
+        left outer join extension_oids e on c.oid = e.objid
+        -- <EXCLUDE_INTERNAL>
+        where not c.collnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+        and e.objid is null
+        -- </EXCLUDE_INTERNAL>
+      order by
+        1, 2;
+    `;
+        }
+        else {
+            // On postgres 15 icu_rules does not exist
+            collations = await sql `
+      with extension_oids as (
+        select
+          objid
+        from
+          pg_depend d
+        where
+          d.refclassid = 'pg_extension'::regclass
+          and d.classid = 'pg_collation'::regclass
+      )
+      select
+        c.collnamespace::regnamespace::text as schema,
+        quote_ident(c.collname) as name,
+        c.collprovider as provider,
+        c.collisdeterministic as is_deterministic,
+        c.collencoding as encoding,
+        c.collcollate as collate,
+        c.collctype as ctype,
+        colliculocale as locale,
+        null as icu_rules,
+        c.collversion as version,
+        c.collowner::regrole::text as owner,
+        obj_description(c.oid, 'pg_collation') as comment
+      from
+        pg_catalog.pg_collation c
+        left outer join extension_oids e on c.oid = e.objid
+        -- <EXCLUDE_INTERNAL>
+        where not c.collnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+        and e.objid is null
+        -- </EXCLUDE_INTERNAL>
+      order by
+        1, 2;
+    `;
+        }
+        // Validate and parse each row using the Zod schema
+        const validatedRows = collations.map((row) => collationPropsSchema.parse(row));
+        return validatedRows.map((row) => new Collation(row));
+    });
+}

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

@@ -0,0 +1,143 @@
+import type { Domain, DomainConstraintProps } from "../domain.model.ts";
+import { AlterDomainChange, DropDomainChange } from "./domain.base.ts";
+/**
+ * Alter a domain.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterdomain.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER DOMAIN name
+ *     { SET DEFAULT expression | DROP DEFAULT }
+ * ALTER DOMAIN name
+ *     { SET | DROP } NOT NULL
+ * ALTER DOMAIN name
+ *     ADD domain_constraint [ NOT VALID ]
+ * ALTER DOMAIN name
+ *     DROP CONSTRAINT [ IF EXISTS ] constraint_name [ RESTRICT | CASCADE ]
+ * ALTER DOMAIN name
+ *     RENAME CONSTRAINT constraint_name TO new_constraint_name
+ * ALTER DOMAIN name
+ *     VALIDATE CONSTRAINT constraint_name
+ * ALTER DOMAIN name
+ *     OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ * ALTER DOMAIN name
+ *     RENAME TO new_name
+ * ALTER DOMAIN name
+ *     SET SCHEMA new_schema
+ *
+ * where domain_constraint is:
+ *
+ *     [ CONSTRAINT constraint_name ]
+ *     { NOT NULL | CHECK (expression) }
+ * ```
+ */
+export type AlterDomain = AlterDomainAddConstraint | AlterDomainChangeOwner | AlterDomainDropConstraint | AlterDomainDropDefault | AlterDomainDropNotNull | AlterDomainSetDefault | AlterDomainSetNotNull | AlterDomainValidateConstraint;
+/**
+ * ALTER DOMAIN ... SET DEFAULT ...
+ */
+export declare class AlterDomainSetDefault extends AlterDomainChange {
+    readonly domain: Domain;
+    readonly defaultValue: string;
+    readonly scope: "object";
+    constructor(props: {
+        domain: Domain;
+        defaultValue: string;
+    });
+    get requires(): `domain:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER DOMAIN ... DROP DEFAULT
+ */
+export declare class AlterDomainDropDefault extends AlterDomainChange {
+    readonly domain: Domain;
+    readonly scope: "object";
+    constructor(props: {
+        domain: Domain;
+    });
+    get requires(): `domain:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER DOMAIN ... SET NOT NULL
+ */
+export declare class AlterDomainSetNotNull extends AlterDomainChange {
+    readonly domain: Domain;
+    readonly scope: "object";
+    constructor(props: {
+        domain: Domain;
+    });
+    get requires(): `domain:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER DOMAIN ... DROP NOT NULL
+ */
+export declare class AlterDomainDropNotNull extends AlterDomainChange {
+    readonly domain: Domain;
+    readonly scope: "object";
+    constructor(props: {
+        domain: Domain;
+    });
+    get requires(): `domain:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER DOMAIN ... OWNER TO ...
+ */
+export declare class AlterDomainChangeOwner extends AlterDomainChange {
+    readonly domain: Domain;
+    readonly owner: string;
+    readonly scope: "object";
+    constructor(props: {
+        domain: Domain;
+        owner: string;
+    });
+    get requires(): (`role:${string}` | `domain:${string}`)[];
+    serialize(): string;
+}
+/**
+ * ALTER DOMAIN ... ADD CONSTRAINT ... [ NOT VALID ]
+ */
+export declare class AlterDomainAddConstraint extends AlterDomainChange {
+    readonly domain: Domain;
+    readonly constraint: DomainConstraintProps;
+    readonly scope: "object";
+    constructor(props: {
+        domain: Domain;
+        constraint: DomainConstraintProps;
+    });
+    get creates(): `constraint:${string}.${string}.${string}`[];
+    get requires(): `domain:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER DOMAIN ... DROP CONSTRAINT ...
+ */
+export declare class AlterDomainDropConstraint extends DropDomainChange {
+    readonly domain: Domain;
+    readonly constraint: DomainConstraintProps;
+    readonly scope: "object";
+    constructor(props: {
+        domain: Domain;
+        constraint: DomainConstraintProps;
+    });
+    get requires(): (`constraint:${string}.${string}.${string}` | `domain:${string}`)[];
+    get drops(): `constraint:${string}.${string}.${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER DOMAIN ... VALIDATE CONSTRAINT ...
+ */
+export declare class AlterDomainValidateConstraint extends AlterDomainChange {
+    readonly domain: Domain;
+    readonly constraint: DomainConstraintProps;
+    readonly scope: "object";
+    constructor(props: {
+        domain: Domain;
+        constraint: DomainConstraintProps;
+    });
+    get requires(): (`constraint:${string}.${string}.${string}` | `domain:${string}`)[];
+    serialize(): string;
+}

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

@@ -0,0 +1,191 @@
+import { stableId } from "../../utils.js";
+import { AlterDomainChange, DropDomainChange } from "./domain.base.js";
+/**
+ * ALTER DOMAIN ... SET DEFAULT ...
+ */
+export class AlterDomainSetDefault extends AlterDomainChange {
+    domain;
+    defaultValue;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.domain = props.domain;
+        this.defaultValue = props.defaultValue;
+    }
+    get requires() {
+        return [this.domain.stableId];
+    }
+    serialize() {
+        return `ALTER DOMAIN ${this.domain.schema}.${this.domain.name} SET DEFAULT ${this.defaultValue}`;
+    }
+}
+/**
+ * ALTER DOMAIN ... DROP DEFAULT
+ */
+export class AlterDomainDropDefault extends AlterDomainChange {
+    domain;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.domain = props.domain;
+    }
+    get requires() {
+        return [this.domain.stableId];
+    }
+    serialize() {
+        return `ALTER DOMAIN ${this.domain.schema}.${this.domain.name} DROP DEFAULT`;
+    }
+}
+/**
+ * ALTER DOMAIN ... SET NOT NULL
+ */
+export class AlterDomainSetNotNull extends AlterDomainChange {
+    domain;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.domain = props.domain;
+    }
+    get requires() {
+        return [this.domain.stableId];
+    }
+    serialize() {
+        return `ALTER DOMAIN ${this.domain.schema}.${this.domain.name} SET NOT NULL`;
+    }
+}
+/**
+ * ALTER DOMAIN ... DROP NOT NULL
+ */
+export class AlterDomainDropNotNull extends AlterDomainChange {
+    domain;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.domain = props.domain;
+    }
+    get requires() {
+        return [this.domain.stableId];
+    }
+    serialize() {
+        return `ALTER DOMAIN ${this.domain.schema}.${this.domain.name} DROP NOT NULL`;
+    }
+}
+/**
+ * ALTER DOMAIN ... OWNER TO ...
+ */
+export class AlterDomainChangeOwner extends AlterDomainChange {
+    domain;
+    owner;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.domain = props.domain;
+        this.owner = props.owner;
+    }
+    get requires() {
+        return [this.domain.stableId, stableId.role(this.owner)];
+    }
+    serialize() {
+        return `ALTER DOMAIN ${this.domain.schema}.${this.domain.name} OWNER TO ${this.owner}`;
+    }
+}
+/**
+ * ALTER DOMAIN ... ADD CONSTRAINT ... [ NOT VALID ]
+ */
+export class AlterDomainAddConstraint extends AlterDomainChange {
+    domain;
+    constraint;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.domain = props.domain;
+        this.constraint = props.constraint;
+    }
+    get creates() {
+        return [
+            stableId.constraint(this.domain.schema, this.domain.name, this.constraint.name),
+        ];
+    }
+    get requires() {
+        return [this.domain.stableId];
+    }
+    serialize() {
+        const domainName = `${this.domain.schema}.${this.domain.name}`;
+        const parts = [
+            "ALTER DOMAIN",
+            domainName,
+            "ADD CONSTRAINT",
+            this.constraint.name,
+        ];
+        if (this.constraint.check_expression) {
+            parts.push(`CHECK (${this.constraint.check_expression})`);
+        }
+        if (!this.constraint.validated) {
+            parts.push("NOT VALID");
+        }
+        return parts.join(" ");
+    }
+}
+/**
+ * ALTER DOMAIN ... DROP CONSTRAINT ...
+ */
+export class AlterDomainDropConstraint extends DropDomainChange {
+    domain;
+    constraint;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.domain = props.domain;
+        this.constraint = props.constraint;
+    }
+    get requires() {
+        return [
+            this.domain.stableId,
+            stableId.constraint(this.domain.schema, this.domain.name, this.constraint.name),
+        ];
+    }
+    get drops() {
+        return [
+            stableId.constraint(this.domain.schema, this.domain.name, this.constraint.name),
+        ];
+    }
+    serialize() {
+        const domainName = `${this.domain.schema}.${this.domain.name}`;
+        return [
+            "ALTER DOMAIN",
+            domainName,
+            "DROP CONSTRAINT",
+            this.constraint.name,
+        ].join(" ");
+    }
+}
+// Constraint renames are modeled as drop+add because the constraint name
+// is part of the identity used in diffing and dependency resolution.
+/**
+ * ALTER DOMAIN ... VALIDATE CONSTRAINT ...
+ */
+export class AlterDomainValidateConstraint extends AlterDomainChange {
+    domain;
+    constraint;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.domain = props.domain;
+        this.constraint = props.constraint;
+    }
+    get requires() {
+        return [
+            this.domain.stableId,
+            stableId.constraint(this.domain.schema, this.domain.name, this.constraint.name),
+        ];
+    }
+    serialize() {
+        const domainName = `${this.domain.schema}.${this.domain.name}`;
+        return [
+            "ALTER DOMAIN",
+            domainName,
+            "VALIDATE CONSTRAINT",
+            this.constraint.name,
+        ].join(" ");
+    }
+}

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

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Domain } from "../domain.model.ts";
+declare abstract class BaseDomainChange extends BaseChange {
+    abstract readonly domain: Domain;
+    abstract readonly scope: "object" | "comment" | "privilege";
+    readonly objectType: "domain";
+}
+export declare abstract class CreateDomainChange extends BaseDomainChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterDomainChange extends BaseDomainChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropDomainChange extends BaseDomainChange {
+    readonly operation: "drop";
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../base.change.js";
+class BaseDomainChange extends BaseChange {
+    objectType = "domain";
+}
+export class CreateDomainChange extends BaseDomainChange {
+    operation = "create";
+}
+export class AlterDomainChange extends BaseDomainChange {
+    operation = "alter";
+}
+export class DropDomainChange extends BaseDomainChange {
+    operation = "drop";
+}

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

@@ -0,0 +1,25 @@
+import type { Domain } from "../domain.model.ts";
+import { CreateDomainChange, DropDomainChange } from "./domain.base.ts";
+export type CommentDomain = CreateCommentOnDomain | DropCommentOnDomain;
+/**
+ * Create/drop comments on domains.
+ */
+export declare class CreateCommentOnDomain extends CreateDomainChange {
+    readonly domain: Domain;
+    readonly scope: "comment";
+    constructor(props: {
+        domain: Domain;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `domain:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnDomain extends DropDomainChange {
+    readonly domain: Domain;
+    readonly scope: "comment";
+    constructor(props: {
+        domain: Domain;
+    });
+    get requires(): (`comment:${string}` | `domain:${string}`)[];
+    serialize(): string;
+}