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

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

@@ -0,0 +1,72 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+declare const RuleEnabledStateSchema: z.ZodEnum<{
+    O: "O";
+    D: "D";
+    R: "R";
+    A: "A";
+}>;
+declare const rulePropsSchema: z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+    table_name: z.ZodString;
+    relation_kind: z.ZodEnum<{
+        r: "r";
+        v: "v";
+        m: "m";
+        p: "p";
+        f: "f";
+    }>;
+    event: z.ZodEnum<{
+        DELETE: "DELETE";
+        INSERT: "INSERT";
+        SELECT: "SELECT";
+        UPDATE: "UPDATE";
+    }>;
+    enabled: z.ZodEnum<{
+        O: "O";
+        D: "D";
+        R: "R";
+        A: "A";
+    }>;
+    is_instead: z.ZodBoolean;
+    owner: z.ZodString;
+    definition: z.ZodString;
+    comment: z.ZodNullable<z.ZodString>;
+    columns: z.ZodArray<z.ZodString>;
+}, z.z.core.$strip>;
+export type RuleEnabledState = z.infer<typeof RuleEnabledStateSchema>;
+export type RuleProps = z.infer<typeof rulePropsSchema>;
+export declare class Rule extends BasePgModel {
+    readonly schema: RuleProps["schema"];
+    readonly name: RuleProps["name"];
+    readonly table_name: RuleProps["table_name"];
+    readonly relation_kind: RuleProps["relation_kind"];
+    readonly event: RuleProps["event"];
+    readonly enabled: RuleProps["enabled"];
+    readonly is_instead: RuleProps["is_instead"];
+    readonly owner: RuleProps["owner"];
+    readonly definition: RuleProps["definition"];
+    readonly comment: RuleProps["comment"];
+    readonly columns: RuleProps["columns"];
+    constructor(props: RuleProps);
+    get stableId(): `rule:${string}`;
+    get identityFields(): {
+        schema: string;
+        name: string;
+        table_name: string;
+    };
+    get dataFields(): {
+        event: "DELETE" | "INSERT" | "SELECT" | "UPDATE";
+        enabled: "O" | "D" | "R" | "A";
+        is_instead: boolean;
+        owner: string;
+        definition: string;
+        comment: string | null;
+        columns: string[];
+    };
+    get relationStableId(): string;
+}
+export declare function extractRules(sql: Sql): Promise<Rule[]>;
+export {};

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

@@ -0,0 +1,156 @@
+import z from "zod";
+import { BasePgModel } from "../base.model.js";
+import { stableId } from "../utils.js";
+const RuleEventSchema = z.enum(["SELECT", "INSERT", "UPDATE", "DELETE"]);
+const RuleEnabledStateSchema = z.enum(["O", "D", "R", "A"]);
+const RuleRelationKindSchema = z.enum([
+    "r", // ordinary table
+    "p", // partitioned table
+    "f", // foreign table
+    "v", // view
+    "m", // materialized view
+]);
+const rulePropsSchema = z.object({
+    schema: z.string(),
+    name: z.string(),
+    table_name: z.string(),
+    relation_kind: RuleRelationKindSchema,
+    event: RuleEventSchema,
+    enabled: RuleEnabledStateSchema,
+    is_instead: z.boolean(),
+    owner: z.string(),
+    definition: z.string(),
+    comment: z.string().nullable(),
+    columns: z.array(z.string()),
+});
+export class Rule extends BasePgModel {
+    schema;
+    name;
+    table_name;
+    relation_kind;
+    event;
+    enabled;
+    is_instead;
+    owner;
+    definition;
+    comment;
+    columns;
+    constructor(props) {
+        super();
+        this.schema = props.schema;
+        this.name = props.name;
+        this.table_name = props.table_name;
+        this.relation_kind = props.relation_kind;
+        this.event = props.event;
+        this.enabled = props.enabled;
+        this.is_instead = props.is_instead;
+        this.owner = props.owner;
+        this.definition = props.definition;
+        this.comment = props.comment;
+        this.columns = props.columns;
+    }
+    get stableId() {
+        return `rule:${this.schema}.${this.table_name}.${this.name}`;
+    }
+    get identityFields() {
+        return {
+            schema: this.schema,
+            name: this.name,
+            table_name: this.table_name,
+        };
+    }
+    get dataFields() {
+        return {
+            event: this.event,
+            enabled: this.enabled,
+            is_instead: this.is_instead,
+            owner: this.owner,
+            definition: this.definition,
+            comment: this.comment,
+            columns: this.columns,
+        };
+    }
+    get relationStableId() {
+        switch (this.relation_kind) {
+            case "v":
+                return stableId.view(this.schema, this.table_name);
+            case "m":
+                return stableId.materializedView(this.schema, this.table_name);
+            default:
+                return stableId.table(this.schema, this.table_name);
+        }
+    }
+}
+export async function extractRules(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const ruleRows = await sql `
+      WITH extension_rule_oids AS (
+        SELECT
+          objid
+        FROM
+          pg_depend d
+        WHERE
+          d.refclassid = 'pg_extension'::regclass
+          AND d.classid = 'pg_rewrite'::regclass
+      ),
+      extension_relation_oids AS (
+        SELECT
+          objid
+        FROM
+          pg_depend d
+        WHERE
+          d.refclassid = 'pg_extension'::regclass
+          AND d.classid = 'pg_class'::regclass
+          AND d.deptype = 'e'
+      )
+      SELECT
+        c.relnamespace::regnamespace::text AS schema,
+        quote_ident(r.rulename) AS name,
+        quote_ident(c.relname) AS table_name,
+        c.relkind AS relation_kind,
+        CASE r.ev_type
+          WHEN '1' THEN 'SELECT'
+          WHEN '2' THEN 'UPDATE'
+          WHEN '3' THEN 'INSERT'
+          WHEN '4' THEN 'DELETE'
+          ELSE NULL
+        END AS event,
+        r.ev_enabled AS enabled,
+        r.is_instead,
+        c.relowner::regrole::text AS owner,
+        pg_get_ruledef(r.oid, true) AS definition,
+        obj_description(r.oid, 'pg_rewrite') AS comment,
+        COALESCE(
+          (
+            SELECT json_agg(quote_ident(att.attname) ORDER BY dep.refobjsubid)
+            FROM pg_depend dep
+            JOIN pg_attribute att
+              ON att.attrelid = dep.refobjid
+             AND att.attnum = dep.refobjsubid
+             AND att.attnum > 0
+             AND NOT att.attisdropped
+            WHERE dep.classid = 'pg_rewrite'::regclass
+              AND dep.objid = r.oid
+              AND dep.refclassid = 'pg_class'::regclass
+              AND dep.refobjid = c.oid
+              AND dep.refobjsubid > 0
+          ), '[]'
+        ) AS columns
+      FROM
+        pg_catalog.pg_rewrite r
+        JOIN pg_catalog.pg_class c ON c.oid = r.ev_class
+        LEFT JOIN extension_rule_oids e_rule ON r.oid = e_rule.objid
+        LEFT JOIN extension_relation_oids e_rel ON c.oid = e_rel.objid
+      WHERE
+        NOT c.relnamespace::regnamespace::text LIKE ANY (ARRAY['pg\\_%', 'information\\_schema'])
+        AND e_rule.objid IS NULL
+        AND e_rel.objid IS NULL
+        AND r.rulename <> '_RETURN'
+      ORDER BY
+        1, 3, 2;
+    `;
+        const validatedRows = ruleRows.map((row) => rulePropsSchema.parse(row));
+        return validatedRows.map((row) => new Rule(row));
+    });
+}

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

@@ -0,0 +1,32 @@
+import type { Schema } from "../schema.model.ts";
+import { AlterSchemaChange } from "./schema.base.ts";
+/**
+ * Alter a schema.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterschema.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER SCHEMA name RENAME TO new_name
+ * ALTER SCHEMA name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ * ```
+ */
+export type AlterSchema = AlterSchemaChangeOwner;
+/**
+ * ALTER SCHEMA ... OWNER TO ...
+ */
+export declare class AlterSchemaChangeOwner extends AlterSchemaChange {
+    readonly schema: Schema;
+    readonly owner: string;
+    readonly scope: "object";
+    constructor(props: {
+        schema: Schema;
+        owner: string;
+    });
+    get requires(): `schema:${string}`[];
+    serialize(): string;
+}
+/**
+ * Replace a schema by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER SCHEMA change.
+ */

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

@@ -0,0 +1,25 @@
+import { AlterSchemaChange } from "./schema.base.js";
+/**
+ * ALTER SCHEMA ... OWNER TO ...
+ */
+export class AlterSchemaChangeOwner extends AlterSchemaChange {
+    schema;
+    owner;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.schema = props.schema;
+        this.owner = props.owner;
+    }
+    get requires() {
+        return [this.schema.stableId];
+    }
+    serialize() {
+        return ["ALTER SCHEMA", this.schema.name, "OWNER TO", this.owner].join(" ");
+    }
+}
+/**
+ * Replace a schema by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER SCHEMA change.
+ */
+// NOTE: ReplaceSchema removed. Non-alterable changes would be emitted via Drop + Create in schema.diff.ts if needed.

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

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Schema } from "../schema.model.ts";
+declare abstract class BaseSchemaChange extends BaseChange {
+    abstract readonly schema: Schema;
+    abstract readonly scope: "object" | "comment" | "privilege";
+    readonly objectType: "schema";
+}
+export declare abstract class CreateSchemaChange extends BaseSchemaChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterSchemaChange extends BaseSchemaChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropSchemaChange extends BaseSchemaChange {
+    readonly operation: "drop";
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../base.change.js";
+class BaseSchemaChange extends BaseChange {
+    objectType = "schema";
+}
+export class CreateSchemaChange extends BaseSchemaChange {
+    operation = "create";
+}
+export class AlterSchemaChange extends BaseSchemaChange {
+    operation = "alter";
+}
+export class DropSchemaChange extends BaseSchemaChange {
+    operation = "drop";
+}

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

@@ -0,0 +1,23 @@
+import type { Schema } from "../schema.model.ts";
+import { CreateSchemaChange, DropSchemaChange } from "./schema.base.ts";
+export type CommentSchema = CreateCommentOnSchema | DropCommentOnSchema;
+export declare class CreateCommentOnSchema extends CreateSchemaChange {
+    readonly schema: Schema;
+    readonly scope: "comment";
+    constructor(props: {
+        schema: Schema;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `schema:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnSchema extends DropSchemaChange {
+    readonly schema: Schema;
+    readonly scope: "comment";
+    constructor(props: {
+        schema: Schema;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`schema:${string}` | `comment:${string}`)[];
+    serialize(): string;
+}

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

@@ -0,0 +1,43 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateSchemaChange, DropSchemaChange } from "./schema.base.js";
+export class CreateCommentOnSchema extends CreateSchemaChange {
+    schema;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.schema = props.schema;
+    }
+    get creates() {
+        return [stableId.comment(this.schema.stableId)];
+    }
+    get requires() {
+        return [this.schema.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON SCHEMA",
+            this.schema.name,
+            "IS",
+            // biome-ignore lint/style/noNonNullAssertion: schema comment is not nullable in this case
+            quoteLiteral(this.schema.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnSchema extends DropSchemaChange {
+    schema;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.schema = props.schema;
+    }
+    get drops() {
+        return [stableId.comment(this.schema.stableId)];
+    }
+    get requires() {
+        return [stableId.comment(this.schema.stableId), this.schema.stableId];
+    }
+    serialize() {
+        return ["COMMENT ON SCHEMA", this.schema.name, "IS NULL"].join(" ");
+    }
+}

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

@@ -0,0 +1,27 @@
+import type { Schema } from "../schema.model.ts";
+import { CreateSchemaChange } from "./schema.base.ts";
+/**
+ * Create a schema.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createschema.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE SCHEMA [ IF NOT EXISTS ] schema_name [ AUTHORIZATION role_specification ] [ schema_element [ ... ] ]
+ * CREATE SCHEMA [ IF NOT EXISTS ] AUTHORIZATION role_specification [ schema_element [ ... ] ]
+ * CREATE SCHEMA [ IF NOT EXISTS ] schema_name AUTHORIZATION role_specification [ schema_element [ ... ] ]
+ * ```
+ */
+export declare class CreateSchema extends CreateSchemaChange {
+    readonly schema: Schema;
+    readonly scope: "object";
+    constructor(props: {
+        schema: Schema;
+        skipAuthorization?: boolean;
+    });
+    get creates(): `schema:${string}`[];
+    get requires(): `role:${string}`[];
+    serialize(options?: {
+        skipAuthorization?: boolean;
+    }): string;
+}

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

@@ -0,0 +1,38 @@
+import { stableId } from "../../utils.js";
+import { CreateSchemaChange } from "./schema.base.js";
+/**
+ * Create a schema.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createschema.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE SCHEMA [ IF NOT EXISTS ] schema_name [ AUTHORIZATION role_specification ] [ schema_element [ ... ] ]
+ * CREATE SCHEMA [ IF NOT EXISTS ] AUTHORIZATION role_specification [ schema_element [ ... ] ]
+ * CREATE SCHEMA [ IF NOT EXISTS ] schema_name AUTHORIZATION role_specification [ schema_element [ ... ] ]
+ * ```
+ */
+export class CreateSchema extends CreateSchemaChange {
+    schema;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.schema = props.schema;
+    }
+    get creates() {
+        return [this.schema.stableId];
+    }
+    get requires() {
+        return [stableId.role(this.schema.owner)];
+    }
+    serialize(options) {
+        const parts = ["CREATE SCHEMA"];
+        // Add schema name
+        parts.push(this.schema.name);
+        // Add AUTHORIZATION
+        if (!options?.skipAuthorization) {
+            parts.push("AUTHORIZATION", this.schema.owner);
+        }
+        return parts.join(" ");
+    }
+}

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

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

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

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

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

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