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

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

@@ -0,0 +1,25 @@
+import type { Sequence } from "../sequence.model.ts";
+import { CreateSequenceChange } from "./sequence.base.ts";
+/**
+ * Create a sequence.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createsequence.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE [ TEMPORARY | TEMP ] SEQUENCE [ IF NOT EXISTS ] name [ INCREMENT [ BY ] increment ]
+ *     [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ]
+ *     [ START [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]
+ *     [ OWNED BY { table_name.column_name | NONE } ]
+ * ```
+ */
+export declare class CreateSequence extends CreateSequenceChange {
+    readonly sequence: Sequence;
+    readonly scope: "object";
+    constructor(props: {
+        sequence: Sequence;
+    });
+    get creates(): `sequence:${string}`[];
+    get requires(): string[];
+    serialize(): string;
+}

package/dist/core/objects/sequence/changes/sequence.create.js

@@ -0,0 +1,78 @@
+import { stableId } from "../../utils.js";
+import { CreateSequenceChange } from "./sequence.base.js";
+/**
+ * Create a sequence.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createsequence.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE [ TEMPORARY | TEMP ] SEQUENCE [ IF NOT EXISTS ] name [ INCREMENT [ BY ] increment ]
+ *     [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ]
+ *     [ START [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]
+ *     [ OWNED BY { table_name.column_name | NONE } ]
+ * ```
+ */
+export class CreateSequence extends CreateSequenceChange {
+    sequence;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.sequence = props.sequence;
+    }
+    get creates() {
+        return [this.sequence.stableId];
+    }
+    get requires() {
+        const dependencies = new Set();
+        // Schema dependency
+        dependencies.add(stableId.schema(this.sequence.schema));
+        // Owner dependency
+        dependencies.add(stableId.role(this.sequence.owner));
+        // Owned by table/column dependency (if set)
+        if (this.sequence.owned_by_schema &&
+            this.sequence.owned_by_table &&
+            this.sequence.owned_by_column) {
+            dependencies.add(stableId.table(this.sequence.owned_by_schema, this.sequence.owned_by_table));
+            dependencies.add(stableId.column(this.sequence.owned_by_schema, this.sequence.owned_by_table, this.sequence.owned_by_column));
+        }
+        return Array.from(dependencies);
+    }
+    serialize() {
+        const parts = ["CREATE SEQUENCE"];
+        // Add schema and name
+        parts.push(`${this.sequence.schema}.${this.sequence.name}`);
+        // Add data type if not default
+        if (this.sequence.data_type && this.sequence.data_type !== "bigint") {
+            parts.push("AS", this.sequence.data_type);
+        }
+        // Add INCREMENT
+        if (this.sequence.increment !== 1) {
+            parts.push("INCREMENT BY", this.sequence.increment.toString());
+        }
+        // Add MINVALUE if not default (1)
+        if (this.sequence.minimum_value !== BigInt(1)) {
+            parts.push("MINVALUE", this.sequence.minimum_value.toString());
+        }
+        // Add MAXVALUE if not default (depends on data type)
+        const defaultMaxValue = this.sequence.data_type === "integer"
+            ? BigInt("2147483647")
+            : BigInt("9223372036854775807");
+        if (this.sequence.maximum_value !== defaultMaxValue) {
+            parts.push("MAXVALUE", this.sequence.maximum_value.toString());
+        }
+        // Add START
+        if (this.sequence.start_value !== 1) {
+            parts.push("START WITH", this.sequence.start_value.toString());
+        }
+        // Add CACHE
+        if (this.sequence.cache_size !== 1) {
+            parts.push("CACHE", this.sequence.cache_size.toString());
+        }
+        // Add CYCLE only if true (default is NO CYCLE)
+        if (this.sequence.cycle_option) {
+            parts.push("CYCLE");
+        }
+        return parts.join(" ");
+    }
+}

package/dist/core/objects/sequence/changes/sequence.drop.d.ts

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

package/dist/core/objects/sequence/changes/sequence.drop.js

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

package/dist/core/objects/sequence/changes/sequence.privilege.d.ts

@@ -0,0 +1,101 @@
+import type { Sequence } from "../sequence.model.ts";
+import { AlterSequenceChange } from "./sequence.base.ts";
+export type SequencePrivilege = GrantSequencePrivileges | RevokeSequencePrivileges | RevokeGrantOptionSequencePrivileges;
+/**
+ * Grant privileges on a sequence.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { { USAGE | SELECT | UPDATE }
+ *     [, ...] | ALL [ PRIVILEGES ] }
+ *     ON { SEQUENCE sequence_name [, ...]
+ *          | ALL SEQUENCES IN SCHEMA schema_name [, ...] }
+ *     TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *     [ GRANTED BY role_specification ]
+ * ```
+ */
+export declare class GrantSequencePrivileges extends AlterSequenceChange {
+    readonly sequence: Sequence;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        sequence: Sequence;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        version?: number;
+    });
+    get creates(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`role:${string}` | `sequence:${string}`)[];
+    serialize(): string;
+}
+/**
+ * Revoke privileges on a sequence.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { { USAGE | SELECT | UPDATE }
+ *     [, ...] | ALL [ PRIVILEGES ] }
+ *     ON { SEQUENCE sequence_name [, ...]
+ *          | ALL SEQUENCES IN SCHEMA schema_name [, ...] }
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export declare class RevokeSequencePrivileges extends AlterSequenceChange {
+    readonly sequence: Sequence;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        sequence: Sequence;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        version?: number;
+    });
+    get drops(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `sequence:${string}`)[];
+    serialize(): string;
+}
+/**
+ * Revoke grant option for privileges on a sequence.
+ *
+ * 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 RevokeGrantOptionSequencePrivileges extends AlterSequenceChange {
+    readonly sequence: Sequence;
+    readonly grantee: string;
+    readonly privilegeNames: string[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        sequence: Sequence;
+        grantee: string;
+        privilegeNames: string[];
+        version?: number;
+    });
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `sequence:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/sequence/changes/sequence.privilege.js

@@ -0,0 +1,135 @@
+import { formatObjectPrivilegeList, getObjectKindPrefix, } from "../../base.privilege.js";
+import { stableId } from "../../utils.js";
+import { AlterSequenceChange } from "./sequence.base.js";
+/**
+ * Grant privileges on a sequence.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { { USAGE | SELECT | UPDATE }
+ *     [, ...] | ALL [ PRIVILEGES ] }
+ *     ON { SEQUENCE sequence_name [, ...]
+ *          | ALL SEQUENCES IN SCHEMA schema_name [, ...] }
+ *     TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *     [ GRANTED BY role_specification ]
+ * ```
+ */
+export class GrantSequencePrivileges extends AlterSequenceChange {
+    sequence;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.sequence = props.sequence;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get creates() {
+        return [stableId.acl(this.sequence.stableId, this.grantee)];
+    }
+    get requires() {
+        return [this.sequence.stableId, stableId.role(this.grantee)];
+    }
+    serialize() {
+        const hasGrantable = this.privileges.some((p) => p.grantable);
+        const hasBase = this.privileges.some((p) => !p.grantable);
+        if (hasGrantable && hasBase) {
+            throw new Error("GrantSequencePrivileges expects privileges with uniform grantable flag");
+        }
+        const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+        const kindPrefix = getObjectKindPrefix("SEQUENCE");
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("SEQUENCE", list, this.version);
+        const sequenceName = `${this.sequence.schema}.${this.sequence.name}`;
+        return `GRANT ${privSql} ${kindPrefix} ${sequenceName} TO ${this.grantee}${withGrant}`;
+    }
+}
+/**
+ * Revoke privileges on a sequence.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { { USAGE | SELECT | UPDATE }
+ *     [, ...] | ALL [ PRIVILEGES ] }
+ *     ON { SEQUENCE sequence_name [, ...]
+ *          | ALL SEQUENCES IN SCHEMA schema_name [, ...] }
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class RevokeSequencePrivileges extends AlterSequenceChange {
+    sequence;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.sequence = props.sequence;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get drops() {
+        // Return ACL ID for dependency tracking, even though this is an ALTER operation
+        // Phase assignment now uses operation type, so this won't affect phase placement
+        return [stableId.acl(this.sequence.stableId, this.grantee)];
+    }
+    get requires() {
+        return [
+            stableId.acl(this.sequence.stableId, this.grantee),
+            this.sequence.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const kindPrefix = getObjectKindPrefix("SEQUENCE");
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("SEQUENCE", list, this.version);
+        const sequenceName = `${this.sequence.schema}.${this.sequence.name}`;
+        return `REVOKE ${privSql} ${kindPrefix} ${sequenceName} FROM ${this.grantee}`;
+    }
+}
+/**
+ * Revoke grant option for privileges on a sequence.
+ *
+ * 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 class RevokeGrantOptionSequencePrivileges extends AlterSequenceChange {
+    sequence;
+    grantee;
+    privilegeNames;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.sequence = props.sequence;
+        this.grantee = props.grantee;
+        this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+        this.version = props.version;
+    }
+    get requires() {
+        return [
+            stableId.acl(this.sequence.stableId, this.grantee),
+            this.sequence.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const kindPrefix = getObjectKindPrefix("SEQUENCE");
+        const privSql = formatObjectPrivilegeList("SEQUENCE", this.privilegeNames, this.version);
+        const sequenceName = `${this.sequence.schema}.${this.sequence.name}`;
+        return `REVOKE GRANT OPTION FOR ${privSql} ${kindPrefix} ${sequenceName} FROM ${this.grantee}`;
+    }
+}

package/dist/core/objects/sequence/changes/sequence.types.d.ts

@@ -0,0 +1,6 @@
+import type { AlterSequence } from "./sequence.alter.ts";
+import type { CommentSequence } from "./sequence.comment.ts";
+import type { CreateSequence } from "./sequence.create.ts";
+import type { DropSequence } from "./sequence.drop.ts";
+import type { SequencePrivilege } from "./sequence.privilege.ts";
+export type SequenceChange = AlterSequence | CommentSequence | CreateSequence | DropSequence | SequencePrivilege;

package/dist/core/objects/sequence/changes/sequence.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,20 @@
+import type { DefaultPrivilegeState } from "../base.default-privileges.ts";
+import type { Role } from "../role/role.model.ts";
+import type { Table } from "../table/table.model.ts";
+import type { SequenceChange } from "./changes/sequence.types.ts";
+import type { Sequence } from "./sequence.model.ts";
+/**
+ * Diff two sets of sequences from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @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).
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export declare function diffSequences(ctx: {
+    version: number;
+    currentUser: string;
+    defaultPrivilegeState: DefaultPrivilegeState;
+    mainRoles: Record<string, Role>;
+}, main: Record<string, Sequence>, branch: Record<string, Sequence>, branchTables?: Record<string, Table>): SequenceChange[];