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

package/dist/core/objects/publication/publication.diff.js

@@ -0,0 +1,161 @@
+import { diffObjects } from "../base.diff.js";
+import { deepEqual } from "../utils.js";
+import { AlterPublicationAddSchemas, AlterPublicationAddTables, AlterPublicationDropSchemas, AlterPublicationDropTables, AlterPublicationSetForAllTables, AlterPublicationSetOptions, AlterPublicationSetOwner, } from "./changes/publication.alter.js";
+import { CreateCommentOnPublication, DropCommentOnPublication, } from "./changes/publication.comment.js";
+import { CreatePublication } from "./changes/publication.create.js";
+import { DropPublication } from "./changes/publication.drop.js";
+export function diffPublications(ctx, main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const id of created) {
+        const publication = branch[id];
+        changes.push(new CreatePublication({ publication }));
+        // OWNER: If the publication should be owned by someone other than the current user,
+        // emit ALTER PUBLICATION ... OWNER TO after creation
+        if (publication.owner !== ctx.currentUser) {
+            changes.push(new AlterPublicationSetOwner({
+                publication,
+                owner: publication.owner,
+            }));
+        }
+        if (publication.comment !== null) {
+            changes.push(new CreateCommentOnPublication({ publication }));
+        }
+    }
+    for (const id of dropped) {
+        changes.push(new DropPublication({ publication: main[id] }));
+    }
+    for (const id of altered) {
+        const mainPublication = main[id];
+        const branchPublication = branch[id];
+        if (mainPublication.all_tables && !branchPublication.all_tables) {
+            changes.push(new DropPublication({ publication: mainPublication }));
+            changes.push(new CreatePublication({ publication: branchPublication }));
+            if (branchPublication.comment !== null) {
+                changes.push(new CreateCommentOnPublication({ publication: branchPublication }));
+            }
+            continue;
+        }
+        const operationsChanged = mainPublication.publish_insert !== branchPublication.publish_insert ||
+            mainPublication.publish_update !== branchPublication.publish_update ||
+            mainPublication.publish_delete !== branchPublication.publish_delete ||
+            mainPublication.publish_truncate !== branchPublication.publish_truncate;
+        const publishViaPartitionRootChanged = mainPublication.publish_via_partition_root !==
+            branchPublication.publish_via_partition_root;
+        if (operationsChanged || publishViaPartitionRootChanged) {
+            changes.push(new AlterPublicationSetOptions({
+                publication: branchPublication,
+                setPublish: operationsChanged,
+                setPublishViaPartitionRoot: publishViaPartitionRootChanged,
+            }));
+        }
+        let handledObjectLists = false;
+        if (mainPublication.all_tables !== branchPublication.all_tables) {
+            handledObjectLists = true;
+            if (branchPublication.all_tables) {
+                changes.push(new AlterPublicationSetForAllTables({
+                    publication: branchPublication,
+                }));
+            }
+            else {
+                changes.push(new DropPublication({ publication: mainPublication }));
+                changes.push(new CreatePublication({ publication: branchPublication }));
+                if (branchPublication.comment !== null) {
+                    changes.push(new CreateCommentOnPublication({
+                        publication: branchPublication,
+                    }));
+                }
+                continue;
+            }
+        }
+        if (!handledObjectLists && !branchPublication.all_tables) {
+            const tableDiff = diffPublicationTables(mainPublication.tables, branchPublication.tables);
+            if (tableDiff.tablesToDrop.length > 0) {
+                changes.push(new AlterPublicationDropTables({
+                    publication: mainPublication,
+                    tables: tableDiff.tablesToDrop,
+                }));
+            }
+            if (tableDiff.tablesToAdd.length > 0) {
+                changes.push(new AlterPublicationAddTables({
+                    publication: branchPublication,
+                    tables: tableDiff.tablesToAdd,
+                }));
+            }
+            const schemaDiff = diffPublicationSchemas(mainPublication.schemas, branchPublication.schemas);
+            if (schemaDiff.schemasToDrop.length > 0) {
+                changes.push(new AlterPublicationDropSchemas({
+                    publication: mainPublication,
+                    schemas: schemaDiff.schemasToDrop,
+                }));
+            }
+            if (schemaDiff.schemasToAdd.length > 0) {
+                changes.push(new AlterPublicationAddSchemas({
+                    publication: branchPublication,
+                    schemas: schemaDiff.schemasToAdd,
+                }));
+            }
+        }
+        if (mainPublication.owner !== branchPublication.owner) {
+            changes.push(new AlterPublicationSetOwner({
+                publication: branchPublication,
+                owner: branchPublication.owner,
+            }));
+        }
+        if (mainPublication.comment !== branchPublication.comment) {
+            if (branchPublication.comment === null) {
+                if (mainPublication.comment !== null) {
+                    changes.push(new DropCommentOnPublication({ publication: mainPublication }));
+                }
+            }
+            else {
+                changes.push(new CreateCommentOnPublication({ publication: branchPublication }));
+            }
+        }
+    }
+    return changes;
+}
+function diffPublicationTables(mainTables, branchTables) {
+    const mainMap = new Map(mainTables.map((table) => [`${table.schema}.${table.name}`, table]));
+    const branchMap = new Map(branchTables.map((table) => [`${table.schema}.${table.name}`, table]));
+    const tablesToDropMap = new Map();
+    const tablesToAddMap = new Map();
+    for (const [key, mainTable] of mainMap) {
+        if (!branchMap.has(key)) {
+            tablesToDropMap.set(key, mainTable);
+        }
+    }
+    for (const [key, branchTable] of branchMap) {
+        const mainTable = mainMap.get(key);
+        if (!mainTable) {
+            tablesToAddMap.set(key, branchTable);
+            continue;
+        }
+        const mainComparable = {
+            columns: mainTable.columns,
+            row_filter: mainTable.row_filter,
+        };
+        const branchComparable = {
+            columns: branchTable.columns,
+            row_filter: branchTable.row_filter,
+        };
+        if (!deepEqual(mainComparable, branchComparable)) {
+            tablesToDropMap.set(key, mainTable);
+            tablesToAddMap.set(key, branchTable);
+        }
+    }
+    const tablesToDrop = Array.from(tablesToDropMap.values()).sort((a, b) => {
+        return a.schema.localeCompare(b.schema) || a.name.localeCompare(b.name);
+    });
+    const tablesToAdd = Array.from(tablesToAddMap.values()).sort((a, b) => {
+        return a.schema.localeCompare(b.schema) || a.name.localeCompare(b.name);
+    });
+    return { tablesToDrop, tablesToAdd };
+}
+function diffPublicationSchemas(mainSchemas, branchSchemas) {
+    const mainSet = new Set(mainSchemas);
+    const branchSet = new Set(branchSchemas);
+    const schemasToDrop = [...mainSet.difference(branchSet)].sort((a, b) => a.localeCompare(b));
+    const schemasToAdd = [...branchSet.difference(mainSet)].sort((a, b) => a.localeCompare(b));
+    return { schemasToDrop, schemasToAdd };
+}

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

@@ -0,0 +1,96 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+declare const publicationTablePropsSchema: z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+    columns: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    row_filter: z.ZodNullable<z.ZodString>;
+}, z.z.core.$strip>;
+declare const publicationPropsSchema: z.ZodObject<{
+    name: z.ZodString;
+    owner: z.ZodString;
+    comment: z.ZodNullable<z.ZodString>;
+    all_tables: z.ZodBoolean;
+    publish_insert: z.ZodBoolean;
+    publish_update: z.ZodBoolean;
+    publish_delete: z.ZodBoolean;
+    publish_truncate: z.ZodBoolean;
+    publish_via_partition_root: z.ZodBoolean;
+    tables: z.ZodArray<z.ZodObject<{
+        schema: z.ZodString;
+        name: z.ZodString;
+        columns: z.ZodNullable<z.ZodArray<z.ZodString>>;
+        row_filter: z.ZodNullable<z.ZodString>;
+    }, z.z.core.$strip>>;
+    schemas: z.ZodArray<z.ZodString>;
+}, z.z.core.$strip>;
+export type PublicationTableProps = z.infer<typeof publicationTablePropsSchema>;
+export type PublicationProps = z.infer<typeof publicationPropsSchema>;
+/**
+ * Logical replication publication definition extracted from pg_publication.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createpublication.html
+ */
+export declare class Publication extends BasePgModel {
+    readonly name: PublicationProps["name"];
+    readonly owner: PublicationProps["owner"];
+    readonly comment: PublicationProps["comment"];
+    readonly all_tables: PublicationProps["all_tables"];
+    readonly publish_insert: PublicationProps["publish_insert"];
+    readonly publish_update: PublicationProps["publish_update"];
+    readonly publish_delete: PublicationProps["publish_delete"];
+    readonly publish_truncate: PublicationProps["publish_truncate"];
+    readonly publish_via_partition_root: PublicationProps["publish_via_partition_root"];
+    readonly tables: PublicationTableProps[];
+    readonly schemas: PublicationProps["schemas"];
+    constructor(props: PublicationProps);
+    get stableId(): `publication:${string}`;
+    get identityFields(): {
+        name: string;
+    };
+    get dataFields(): {
+        owner: string;
+        comment: string | null;
+        all_tables: boolean;
+        publish_insert: boolean;
+        publish_update: boolean;
+        publish_delete: boolean;
+        publish_truncate: boolean;
+        publish_via_partition_root: boolean;
+        tables: {
+            schema: string;
+            name: string;
+            columns: string[] | null;
+            row_filter: string | null;
+        }[];
+        schemas: string[];
+    };
+    stableSnapshot(): {
+        identity: {
+            name: string;
+        };
+        data: {
+            tables: {
+                schema: string;
+                name: string;
+                columns: string[] | null;
+                row_filter: string | null;
+            }[];
+            schemas: string[];
+            owner: string;
+            comment: string | null;
+            all_tables: boolean;
+            publish_insert: boolean;
+            publish_update: boolean;
+            publish_delete: boolean;
+            publish_truncate: boolean;
+            publish_via_partition_root: boolean;
+        };
+    };
+}
+/**
+ * Extract all logical replication publications from the database.
+ */
+export declare function extractPublications(sql: Sql): Promise<Publication[]>;
+export {};

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

@@ -0,0 +1,186 @@
+import z from "zod";
+import { BasePgModel } from "../base.model.js";
+const publicationTablePropsSchema = z.object({
+    schema: z.string(),
+    name: z.string(),
+    columns: z.array(z.string()).nullable(),
+    row_filter: z.string().nullable(),
+});
+const publicationPropsSchema = z.object({
+    name: z.string(),
+    owner: z.string(),
+    comment: z.string().nullable(),
+    all_tables: z.boolean(),
+    publish_insert: z.boolean(),
+    publish_update: z.boolean(),
+    publish_delete: z.boolean(),
+    publish_truncate: z.boolean(),
+    publish_via_partition_root: z.boolean(),
+    tables: z.array(publicationTablePropsSchema),
+    schemas: z.array(z.string()),
+});
+/**
+ * Logical replication publication definition extracted from pg_publication.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createpublication.html
+ */
+export class Publication extends BasePgModel {
+    name;
+    owner;
+    comment;
+    all_tables;
+    publish_insert;
+    publish_update;
+    publish_delete;
+    publish_truncate;
+    publish_via_partition_root;
+    tables;
+    schemas;
+    constructor(props) {
+        super();
+        this.name = props.name;
+        this.owner = props.owner;
+        this.comment = props.comment;
+        this.all_tables = props.all_tables;
+        this.publish_insert = props.publish_insert;
+        this.publish_update = props.publish_update;
+        this.publish_delete = props.publish_delete;
+        this.publish_truncate = props.publish_truncate;
+        this.publish_via_partition_root = props.publish_via_partition_root;
+        const normalizedTables = props.tables.map((table) => ({
+            schema: table.schema,
+            name: table.name,
+            columns: table.columns
+                ? [...table.columns].sort((a, b) => a.localeCompare(b))
+                : null,
+            row_filter: table.row_filter,
+        }));
+        this.tables = normalizedTables.sort((a, b) => {
+            return a.schema.localeCompare(b.schema) || a.name.localeCompare(b.name);
+        });
+        this.schemas = [...props.schemas].sort((a, b) => a.localeCompare(b));
+    }
+    get stableId() {
+        return `publication:${this.name}`;
+    }
+    get identityFields() {
+        return {
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            owner: this.owner,
+            comment: this.comment,
+            all_tables: this.all_tables,
+            publish_insert: this.publish_insert,
+            publish_update: this.publish_update,
+            publish_delete: this.publish_delete,
+            publish_truncate: this.publish_truncate,
+            publish_via_partition_root: this.publish_via_partition_root,
+            tables: this.tables,
+            schemas: this.schemas,
+        };
+    }
+    stableSnapshot() {
+        const normalizedTables = this.tables.map((table) => ({
+            schema: table.schema,
+            name: table.name,
+            columns: table.columns
+                ? [...table.columns].sort((a, b) => a.localeCompare(b))
+                : null,
+            row_filter: table.row_filter,
+        }));
+        return {
+            identity: this.identityFields,
+            data: {
+                ...this.dataFields,
+                tables: normalizedTables.sort((a, b) => a.schema.localeCompare(b.schema) || a.name.localeCompare(b.name)),
+                schemas: [...this.schemas].sort((a, b) => a.localeCompare(b)),
+            },
+        };
+    }
+}
+/**
+ * Extract all logical replication publications from the database.
+ */
+export async function extractPublications(sql) {
+    return sql.begin(async (tx) => {
+        await tx `set search_path = ''`;
+        const rows = await tx `
+      with extension_oids as (
+        select objid
+        from pg_depend d
+        where d.refclassid = 'pg_extension'::regclass
+          and d.classid = 'pg_publication'::regclass
+      ),
+      publication_tables as (
+        select
+          pr.prpubid,
+          quote_ident(ns.nspname) as schema,
+          quote_ident(cls.relname) as name,
+          case
+            when pr.prattrs is null then null
+            else (
+              select json_agg(quote_ident(att.attname) order by cols.ord)
+              from unnest(pr.prattrs) with ordinality as cols(attnum, ord)
+              join pg_attribute att
+                on att.attrelid = pr.prrelid
+               and att.attnum = cols.attnum
+            )
+          end as columns,
+          pg_get_expr(pr.prqual, pr.prrelid) as row_filter
+        from pg_publication_rel pr
+        join pg_class cls on cls.oid = pr.prrelid
+        join pg_namespace ns on ns.oid = cls.relnamespace
+      ),
+      publication_schemas as (
+        select
+          pn.pnpubid,
+          quote_ident(ns.nspname) as schema
+        from pg_publication_namespace pn
+        join pg_namespace ns on ns.oid = pn.pnnspid
+      )
+      select
+        quote_ident(p.pubname) as name,
+        p.pubowner::regrole::text as owner,
+        obj_description(p.oid, 'pg_publication') as comment,
+        p.puballtables as all_tables,
+        p.pubinsert as publish_insert,
+        p.pubupdate as publish_update,
+        p.pubdelete as publish_delete,
+        p.pubtruncate as publish_truncate,
+        p.pubviaroot as publish_via_partition_root,
+        coalesce(
+          (
+            select json_agg(
+              json_build_object(
+                'schema', t.schema,
+                'name', t.name,
+                'columns', t.columns,
+                'row_filter', t.row_filter
+              )
+              order by t.schema, t.name
+            )
+            from publication_tables t
+            where t.prpubid = p.oid
+          ),
+          '[]'::json
+        ) as tables,
+        coalesce(
+          (
+            select json_agg(s.schema order by s.schema)
+            from publication_schemas s
+            where s.pnpubid = p.oid
+          ),
+          '[]'::json
+        ) as schemas
+      from pg_publication p
+      left join extension_oids e on e.objid = p.oid
+      where e.objid is null
+      order by 1;
+    `;
+        const validated = rows.map((row) => publicationPropsSchema.parse(row));
+        return validated.map((row) => new Publication(row));
+    });
+}

package/dist/core/objects/publication/utils.d.ts

@@ -0,0 +1,5 @@
+import type { Publication, PublicationTableProps } from "./publication.model.ts";
+export declare function formatPublicationTable(table: PublicationTableProps): string;
+export declare function formatPublicationObjects(tables: PublicationTableProps[], schemas: string[]): string[];
+export declare function getPublicationOperations(publication: Publication): string[];
+export declare function isDefaultPublicationOperations(publication: Publication): boolean;

package/dist/core/objects/publication/utils.js

@@ -0,0 +1,45 @@
+function wrapRowFilter(expression) {
+    const trimmed = expression.trim();
+    if (trimmed.startsWith("(") && trimmed.endsWith(")")) {
+        return trimmed;
+    }
+    return `(${trimmed})`;
+}
+export function formatPublicationTable(table) {
+    let clause = `TABLE ${table.schema}.${table.name}`;
+    if (table.columns && table.columns.length > 0) {
+        clause += ` (${table.columns.join(", ")})`;
+    }
+    if (table.row_filter) {
+        clause += ` WHERE ${wrapRowFilter(table.row_filter)}`;
+    }
+    return clause;
+}
+export function formatPublicationObjects(tables, schemas) {
+    const clauses = [];
+    for (const table of tables) {
+        clauses.push(formatPublicationTable(table));
+    }
+    for (const schema of schemas) {
+        clauses.push(`TABLES IN SCHEMA ${schema}`);
+    }
+    return clauses;
+}
+export function getPublicationOperations(publication) {
+    const operations = [];
+    if (publication.publish_insert)
+        operations.push("insert");
+    if (publication.publish_update)
+        operations.push("update");
+    if (publication.publish_delete)
+        operations.push("delete");
+    if (publication.publish_truncate)
+        operations.push("truncate");
+    return operations;
+}
+export function isDefaultPublicationOperations(publication) {
+    return (publication.publish_insert &&
+        publication.publish_update &&
+        publication.publish_delete &&
+        publication.publish_truncate);
+}

package/dist/core/objects/rls-policy/changes/rls-policy.alter.d.ts

@@ -0,0 +1,62 @@
+import type { RlsPolicy } from "../rls-policy.model.ts";
+import { AlterRlsPolicyChange } from "./rls-policy.base.ts";
+/**
+ * Alter an RLS policy.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterpolicy.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER POLICY name ON table_name
+ *     [ TO { role_name | PUBLIC | CURRENT_ROLE | CURRENT_USER | SESSION_USER } [, ...] ]
+ *     [ USING ( using_expression ) ]
+ *     [ WITH CHECK ( with_check_expression ) ]
+ * ```
+ */
+export type AlterRlsPolicy = AlterRlsPolicySetRoles | AlterRlsPolicySetUsingExpression | AlterRlsPolicySetWithCheckExpression;
+/**
+ * ALTER POLICY ... TO roles ...
+ */
+export declare class AlterRlsPolicySetRoles extends AlterRlsPolicyChange {
+    readonly policy: RlsPolicy;
+    readonly roles: string[];
+    readonly scope: "object";
+    constructor(props: {
+        policy: RlsPolicy;
+        roles: string[];
+    });
+    get requires(): `rlsPolicy:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER POLICY ... USING (...)
+ */
+export declare class AlterRlsPolicySetUsingExpression extends AlterRlsPolicyChange {
+    readonly policy: RlsPolicy;
+    readonly usingExpression: string | null;
+    readonly scope: "object";
+    constructor(props: {
+        policy: RlsPolicy;
+        usingExpression: string | null;
+    });
+    get requires(): `rlsPolicy:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER POLICY ... WITH CHECK (...)
+ */
+export declare class AlterRlsPolicySetWithCheckExpression extends AlterRlsPolicyChange {
+    readonly policy: RlsPolicy;
+    readonly withCheckExpression: string | null;
+    readonly scope: "object";
+    constructor(props: {
+        policy: RlsPolicy;
+        withCheckExpression: string | null;
+    });
+    get requires(): `rlsPolicy:${string}`[];
+    serialize(): string;
+}
+/**
+ * Replace an RLS policy by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER POLICY change.
+ */

package/dist/core/objects/rls-policy/changes/rls-policy.alter.js

@@ -0,0 +1,90 @@
+import { AlterRlsPolicyChange } from "./rls-policy.base.js";
+/**
+ * ALTER POLICY ... TO roles ...
+ */
+export class AlterRlsPolicySetRoles extends AlterRlsPolicyChange {
+    policy;
+    roles;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.policy = props.policy;
+        this.roles = props.roles;
+    }
+    get requires() {
+        return [this.policy.stableId];
+    }
+    serialize() {
+        const targetRoles = this.roles;
+        const toPublic = targetRoles.length === 0 ||
+            (targetRoles.length === 1 && targetRoles[0].toLowerCase() === "public");
+        const rolesSql = toPublic ? "PUBLIC" : targetRoles.join(", ");
+        return [
+            "ALTER POLICY",
+            `${this.policy.schema}.${this.policy.name}`,
+            "ON",
+            `${this.policy.schema}.${this.policy.table_name}`,
+            "TO",
+            rolesSql,
+        ].join(" ");
+    }
+}
+/**
+ * ALTER POLICY ... USING (...)
+ */
+export class AlterRlsPolicySetUsingExpression extends AlterRlsPolicyChange {
+    policy;
+    usingExpression;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.policy = props.policy;
+        this.usingExpression = props.usingExpression;
+    }
+    get requires() {
+        return [this.policy.stableId];
+    }
+    serialize() {
+        const expr = this.usingExpression ?? "true";
+        return [
+            "ALTER POLICY",
+            `${this.policy.schema}.${this.policy.name}`,
+            "ON",
+            `${this.policy.schema}.${this.policy.table_name}`,
+            "USING",
+            `(${expr})`,
+        ].join(" ");
+    }
+}
+/**
+ * ALTER POLICY ... WITH CHECK (...)
+ */
+export class AlterRlsPolicySetWithCheckExpression extends AlterRlsPolicyChange {
+    policy;
+    withCheckExpression;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.policy = props.policy;
+        this.withCheckExpression = props.withCheckExpression;
+    }
+    get requires() {
+        return [this.policy.stableId];
+    }
+    serialize() {
+        const expr = this.withCheckExpression ?? "true";
+        return [
+            "ALTER POLICY",
+            `${this.policy.schema}.${this.policy.name}`,
+            "ON",
+            `${this.policy.schema}.${this.policy.table_name}`,
+            "WITH CHECK",
+            `(${expr})`,
+        ].join(" ");
+    }
+}
+/**
+ * Replace an RLS policy by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER POLICY change.
+ */
+// NOTE: ReplaceRlsPolicy removed. Non-alterable changes are emitted as Drop + Create in rls-policy.diff.ts.

package/dist/core/objects/rls-policy/changes/rls-policy.base.d.ts

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../base.change.ts";
+import type { RlsPolicy } from "../rls-policy.model.ts";
+declare abstract class BaseRlsPolicyChange extends BaseChange {
+    abstract readonly policy: RlsPolicy;
+    abstract readonly scope: "object" | "comment";
+    readonly objectType: "rls_policy";
+}
+export declare abstract class CreateRlsPolicyChange extends BaseRlsPolicyChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterRlsPolicyChange extends BaseRlsPolicyChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropRlsPolicyChange extends BaseRlsPolicyChange {
+    readonly operation: "drop";
+}
+export {};

package/dist/core/objects/rls-policy/changes/rls-policy.base.js

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../base.change.js";
+class BaseRlsPolicyChange extends BaseChange {
+    objectType = "rls_policy";
+}
+export class CreateRlsPolicyChange extends BaseRlsPolicyChange {
+    operation = "create";
+}
+export class AlterRlsPolicyChange extends BaseRlsPolicyChange {
+    operation = "alter";
+}
+export class DropRlsPolicyChange extends BaseRlsPolicyChange {
+    operation = "drop";
+}