@supabase/pg-delta 1.0.0-alpha.3 → 1.0.0-alpha.30

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

@@ -2,6 +2,7 @@ import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../base.model.js";
 import { privilegePropsSchema, } from "../base.privilege-diff.js";
+import { securityLabelPropsSchema, } from "../security-label.types.js";
 const AggregateKindSchema = z.enum([
     "n", // normal aggregate
     "o", // ordered-set aggregate
@@ -66,6 +67,7 @@ const aggregatePropsSchema = z.object({
     owner: z.string(),
     comment: z.string().nullable(),
     privileges: z.array(privilegePropsSchema),
+    security_labels: z.array(securityLabelPropsSchema).default([]).optional(),
 });
 export class Aggregate extends BasePgModel {
     schema;
@@ -109,6 +111,7 @@ export class Aggregate extends BasePgModel {
     owner;
     comment;
     privileges;
+    security_labels;
     constructor(props) {
         super();
         this.schema = props.schema;
@@ -153,6 +156,7 @@ export class Aggregate extends BasePgModel {
         this.owner = props.owner;
         this.comment = props.comment;
         this.privileges = props.privileges;
+        this.security_labels = props.security_labels ?? [];
     }
     get stableId() {
         const normalized = this.identityArguments;
@@ -206,6 +210,7 @@ export class Aggregate extends BasePgModel {
             owner: this.owner,
             comment: this.comment,
             privileges: this.privileges,
+            security_labels: this.security_labels,
         };
     }
 }
@@ -273,9 +278,22 @@ select
         )
         order by x.grantee, x.privilege_type
       )
-      from lateral aclexplode(p.proacl) as x(grantor, grantee, privilege_type, is_grantable)
+      from lateral aclexplode(COALESCE(p.proacl, acldefault('f', p.proowner))) as x(grantor, grantee, privilege_type, is_grantable)
     ), '[]'
-  ) as privileges
+  ) as privileges,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object('provider', sl.provider, 'label', sl.label)
+        order by sl.provider
+      )
+      from pg_catalog.pg_seclabel sl
+      where sl.objoid = p.oid
+        and sl.classoid = 'pg_proc'::regclass
+        and sl.objsubid = 0
+    ),
+    '[]'::json
+  ) as security_labels
 from
   pg_catalog.pg_proc p
   inner join pg_catalog.pg_aggregate a on a.aggfnoid = p.oid

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Aggregate } from "../aggregate.model.ts";
 import { AlterAggregateChange } from "./aggregate.base.ts";
 export type AlterAggregate = AlterAggregateChangeOwner;
@@ -15,5 +16,5 @@ export declare class AlterAggregateChangeOwner extends AlterAggregateChange {
         owner: string;
     });
     get requires(): `aggregate:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -16,7 +16,7 @@ export class AlterAggregateChangeOwner extends AlterAggregateChange {
     get requires() {
         return [this.aggregate.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const signature = this.aggregate.identityArguments;
         const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
         const withArgs = signature.length > 0 ? `(${signature})` : "()";

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

@@ -2,7 +2,7 @@ import { BaseChange } from "../../base.change.ts";
 import type { Aggregate } from "../aggregate.model.ts";
 declare abstract class BaseAggregateChange extends BaseChange {
     abstract readonly aggregate: Aggregate;
-    abstract readonly scope: "object" | "comment" | "privilege";
+    abstract readonly scope: "object" | "comment" | "privilege" | "security_label";
     readonly objectType: "aggregate";
 }
 export declare abstract class CreateAggregateChange extends BaseAggregateChange {

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Aggregate } from "../aggregate.model.ts";
 import { CreateAggregateChange, DropAggregateChange } from "./aggregate.base.ts";
 export type CommentAggregate = CreateCommentOnAggregate | DropCommentOnAggregate;
@@ -9,7 +10,7 @@ export declare class CreateCommentOnAggregate extends CreateAggregateChange {
     });
     get creates(): `comment:${string}`[];
     get requires(): `aggregate:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class DropCommentOnAggregate extends DropAggregateChange {
     readonly aggregate: Aggregate;
@@ -19,5 +20,5 @@ export declare class DropCommentOnAggregate extends DropAggregateChange {
     });
     get drops(): `comment:${string}`[];
     get requires(): (`comment:${string}` | `aggregate:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -14,7 +14,7 @@ export class CreateCommentOnAggregate extends CreateAggregateChange {
     get requires() {
         return [this.aggregate.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const signature = this.aggregate.identityArguments;
         const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
         const withArgs = signature.length > 0 ? `(${signature})` : "()";
@@ -35,7 +35,7 @@ export class DropCommentOnAggregate extends DropAggregateChange {
     get requires() {
         return [stableId.comment(this.aggregate.stableId), this.aggregate.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const signature = this.aggregate.identityArguments;
         const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
         const withArgs = signature.length > 0 ? `(${signature})` : "()";

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Aggregate } from "../aggregate.model.ts";
 import { CreateAggregateChange } from "./aggregate.base.ts";
 /**
@@ -15,5 +16,5 @@ export declare class CreateAggregate extends CreateAggregateChange {
     });
     get creates(): `aggregate:${string}`[];
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -110,7 +110,7 @@ export class CreateAggregate extends CreateAggregateChange {
         // may reference types/functions). For now, we rely on pg_depend for these.
         return Array.from(dependencies);
     }
-    serialize() {
+    serialize(_options) {
         const signature = this.aggregate.identityArguments;
         const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
         const head = [
@@ -183,7 +183,7 @@ export class CreateAggregate extends CreateAggregateChange {
             clauses.push(`SORTOP = ${formatOperator(this.aggregate.sort_operator)}`);
         }
         if (this.aggregate.parallel_safety !== "u") {
-            clauses.push(`PARALLEL ${formatParallel(this.aggregate.parallel_safety)}`);
+            clauses.push(`PARALLEL = ${formatParallel(this.aggregate.parallel_safety)}`);
         }
         if (this.aggregate.is_strict) {
             clauses.push("STRICT");

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Aggregate } from "../aggregate.model.ts";
 import { DropAggregateChange } from "./aggregate.base.ts";
 /**
@@ -13,5 +14,5 @@ export declare class DropAggregate extends DropAggregateChange {
     });
     get drops(): `aggregate:${string}`[];
     get requires(): `aggregate:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -17,10 +17,10 @@ export class DropAggregate extends DropAggregateChange {
     get requires() {
         return [this.aggregate.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const signature = this.aggregate.identityArguments;
         const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
-        const withArgs = signature.length > 0 ? `(${signature})` : "()";
+        const withArgs = signature.length > 0 ? `(${signature})` : "(*)";
         return `DROP AGGREGATE ${qualifiedName}${withArgs}`;
     }
 }

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Aggregate } from "../aggregate.model.ts";
 import { AlterAggregateChange } from "./aggregate.base.ts";
 export type AggregatePrivilege = GrantAggregatePrivileges | RevokeAggregatePrivileges | RevokeGrantOptionAggregatePrivileges;
@@ -21,7 +22,7 @@ export declare class GrantAggregatePrivileges extends AlterAggregateChange {
     });
     get creates(): `acl:${string}::grantee:${string}`[];
     get requires(): (`role:${string}` | `aggregate:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class RevokeAggregatePrivileges extends AlterAggregateChange {
     readonly aggregate: Aggregate;
@@ -43,7 +44,7 @@ export declare class RevokeAggregatePrivileges extends AlterAggregateChange {
     });
     get drops(): `acl:${string}::grantee:${string}`[];
     get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `aggregate:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class RevokeGrantOptionAggregatePrivileges extends AlterAggregateChange {
     readonly aggregate: Aggregate;
@@ -58,5 +59,5 @@ export declare class RevokeGrantOptionAggregatePrivileges extends AlterAggregate
         version?: number;
     });
     get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `aggregate:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -1,6 +1,24 @@
 import { formatObjectPrivilegeList, getObjectKindPrefix, } from "../../base.privilege.js";
 import { stableId } from "../../utils.js";
 import { AlterAggregateChange } from "./aggregate.base.js";
+/**
+ * Build the signature `<schema>.<name>(<argtypes>)` for use inside
+ * `GRANT`/`REVOKE ... ON FUNCTION (...)`.
+ *
+ * The aggregate's `identityArguments` (from
+ * `pg_get_function_identity_arguments`) embeds `ORDER BY` for ordered-set
+ * and hypothetical-set aggregates (`aggkind` of `o`/`h`) and `VARIADIC`
+ * for variadic aggregates — both of which the GRANT parser rejects with
+ * a syntax error. PostgreSQL resolves the aggregate from the positional
+ * argument types alone, so use `argument_types` here regardless of
+ * `aggkind`. Other aggregate DDL (`ALTER AGGREGATE`, `COMMENT ON
+ * AGGREGATE`, `SECURITY LABEL ON AGGREGATE`, `DROP AGGREGATE`) accepts
+ * the identity form and keeps using it.
+ */
+function aggregateGrantSignature(aggregate) {
+    const args = (aggregate.argument_types ?? []).join(", ");
+    return `${aggregate.schema}.${aggregate.name}(${args})`;
+}
 export class GrantAggregatePrivileges extends AlterAggregateChange {
     aggregate;
     grantee;
@@ -20,7 +38,7 @@ export class GrantAggregatePrivileges extends AlterAggregateChange {
     get requires() {
         return [this.aggregate.stableId, stableId.role(this.grantee)];
     }
-    serialize() {
+    serialize(_options) {
         const hasGrantable = this.privileges.some((p) => p.grantable);
         const hasBase = this.privileges.some((p) => !p.grantable);
         if (hasGrantable && hasBase) {
@@ -30,9 +48,7 @@ export class GrantAggregatePrivileges extends AlterAggregateChange {
         const kindPrefix = getObjectKindPrefix("FUNCTION");
         const list = this.privileges.map((p) => p.privilege);
         const privSql = formatObjectPrivilegeList("FUNCTION", list, this.version);
-        const aggregateName = `${this.aggregate.schema}.${this.aggregate.name}`;
-        const signature = this.aggregate.identityArguments;
-        const qualified = `${aggregateName}(${signature})`;
+        const qualified = aggregateGrantSignature(this.aggregate);
         return `GRANT ${privSql} ${kindPrefix} ${qualified} TO ${this.grantee}${withGrant}`;
     }
 }
@@ -61,13 +77,11 @@ export class RevokeAggregatePrivileges extends AlterAggregateChange {
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("FUNCTION");
         const list = this.privileges.map((p) => p.privilege);
         const privSql = formatObjectPrivilegeList("FUNCTION", list, this.version);
-        const aggregateName = `${this.aggregate.schema}.${this.aggregate.name}`;
-        const signature = this.aggregate.identityArguments;
-        const qualified = `${aggregateName}(${signature})`;
+        const qualified = aggregateGrantSignature(this.aggregate);
         return `REVOKE ${privSql} ${kindPrefix} ${qualified} FROM ${this.grantee}`;
     }
 }
@@ -91,12 +105,10 @@ export class RevokeGrantOptionAggregatePrivileges extends AlterAggregateChange {
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("FUNCTION");
         const privSql = formatObjectPrivilegeList("FUNCTION", this.privilegeNames, this.version);
-        const aggregateName = `${this.aggregate.schema}.${this.aggregate.name}`;
-        const signature = this.aggregate.identityArguments;
-        const qualified = `${aggregateName}(${signature})`;
+        const qualified = aggregateGrantSignature(this.aggregate);
         return `REVOKE GRANT OPTION FOR ${privSql} ${kindPrefix} ${qualified} FROM ${this.grantee}`;
     }
 }

package/dist/core/objects/aggregate/changes/aggregate.security-label.d.ts

@@ -0,0 +1,28 @@
+import type { SecurityLabelProps } from "../../security-label.types.ts";
+import type { Aggregate } from "../aggregate.model.ts";
+import { CreateAggregateChange, DropAggregateChange } from "./aggregate.base.ts";
+export type SecurityLabelAggregate = CreateSecurityLabelOnAggregate | DropSecurityLabelOnAggregate;
+export declare class CreateSecurityLabelOnAggregate extends CreateAggregateChange {
+    readonly aggregate: Aggregate;
+    readonly securityLabel: SecurityLabelProps;
+    readonly scope: "security_label";
+    constructor(props: {
+        aggregate: Aggregate;
+        securityLabel: SecurityLabelProps;
+    });
+    get creates(): `securityLabel:${string}::provider:${string}`[];
+    get requires(): `aggregate:${string}`[];
+    serialize(): string;
+}
+export declare class DropSecurityLabelOnAggregate extends DropAggregateChange {
+    readonly aggregate: Aggregate;
+    readonly securityLabel: SecurityLabelProps;
+    readonly scope: "security_label";
+    constructor(props: {
+        aggregate: Aggregate;
+        securityLabel: SecurityLabelProps;
+    });
+    get drops(): `securityLabel:${string}::provider:${string}`[];
+    get requires(): (`securityLabel:${string}::provider:${string}` | `aggregate:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/aggregate/changes/aggregate.security-label.js

@@ -0,0 +1,64 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateAggregateChange, DropAggregateChange, } from "./aggregate.base.js";
+function aggregateIdentity(a) {
+    return `${a.schema}.${a.name}(${a.identityArguments})`;
+}
+export class CreateSecurityLabelOnAggregate extends CreateAggregateChange {
+    aggregate;
+    securityLabel;
+    scope = "security_label";
+    constructor(props) {
+        super();
+        this.aggregate = props.aggregate;
+        this.securityLabel = props.securityLabel;
+    }
+    get creates() {
+        return [
+            stableId.securityLabel(this.aggregate.stableId, this.securityLabel.provider),
+        ];
+    }
+    get requires() {
+        return [this.aggregate.stableId];
+    }
+    serialize() {
+        return [
+            "SECURITY LABEL FOR",
+            this.securityLabel.provider,
+            "ON AGGREGATE",
+            aggregateIdentity(this.aggregate),
+            "IS",
+            quoteLiteral(this.securityLabel.label),
+        ].join(" ");
+    }
+}
+export class DropSecurityLabelOnAggregate extends DropAggregateChange {
+    aggregate;
+    securityLabel;
+    scope = "security_label";
+    constructor(props) {
+        super();
+        this.aggregate = props.aggregate;
+        this.securityLabel = props.securityLabel;
+    }
+    get drops() {
+        return [
+            stableId.securityLabel(this.aggregate.stableId, this.securityLabel.provider),
+        ];
+    }
+    get requires() {
+        return [
+            stableId.securityLabel(this.aggregate.stableId, this.securityLabel.provider),
+            this.aggregate.stableId,
+        ];
+    }
+    serialize() {
+        return [
+            "SECURITY LABEL FOR",
+            this.securityLabel.provider,
+            "ON AGGREGATE",
+            aggregateIdentity(this.aggregate),
+            "IS NULL",
+        ].join(" ");
+    }
+}

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

@@ -3,4 +3,6 @@ import type { CommentAggregate } from "./aggregate.comment.ts";
 import type { CreateAggregate } from "./aggregate.create.ts";
 import type { DropAggregate } from "./aggregate.drop.ts";
 import type { AggregatePrivilege } from "./aggregate.privilege.ts";
-export type AggregateChange = AlterAggregate | CommentAggregate | CreateAggregate | DropAggregate | AggregatePrivilege;
+import type { SecurityLabelAggregate } from "./aggregate.security-label.ts";
+/** Union of all aggregate-related change variants (`objectType: "aggregate"`). @category Change Types */
+export type AggregateChange = AlterAggregate | CommentAggregate | CreateAggregate | DropAggregate | AggregatePrivilege | SecurityLabelAggregate;

package/dist/core/objects/base.change.d.ts

@@ -1,4 +1,25 @@
+import type { SerializeOptions } from "../integrations/serialize/serialize.types.ts";
 type ChangeOperation = "create" | "alter" | "drop";
+/**
+ * Kinds of commit-visibility boundaries a change can force.
+ *
+ * Each kind names a PostgreSQL behavior where a statement's effects only
+ * become usable by later statements after the enclosing transaction commits.
+ * The token becomes the `reason` of the migration unit that follows the
+ * producer run, so adding a kind requires a matching arm in the renderer's
+ * `unitName` switch (the exhaustive switch enforces this at compile time).
+ */
+export type CommitBoundaryReason = "enum_value_visibility";
+/**
+ * Abstract base class for all change objects.
+ *
+ * Every concrete change (e.g. `CreateTable`, `AlterView`) extends this class and
+ * provides an `operation`, `objectType`, and `scope`. The filter DSL flattens
+ * these properties — along with the model sub-object — into path/value pairs
+ * for pattern matching.
+ *
+ * @category Base
+ */
 export declare abstract class BaseChange {
     /**
      * The operation of the change.
@@ -13,9 +34,36 @@ export declare abstract class BaseChange {
      */
     abstract readonly scope: string;
     /**
-     * A unique identifier for the change.
+     * True when the serialized statement cannot run inside a transaction block
+     * (PostgreSQL rejects it with SQLSTATE 25001, e.g. `CREATE INDEX
+     * CONCURRENTLY`, `CREATE SUBSCRIPTION` with `connect = true`).
+     *
+     * The planner emits such a change as its own single-statement migration
+     * unit with `transactionMode: "none"`, and `applyPlan` executes it without
+     * a `BEGIN`/`COMMIT` wrapper. Never derive this from the rendered SQL —
+     * declare it on the change class.
+     *
+     * Defaults to false. Override in subclasses whose statement PostgreSQL
+     * forbids inside a transaction block.
+     */
+    get nonTransactional(): boolean;
+    /**
+     * Non-null when this statement's effects only become usable by later
+     * statements after the enclosing transaction commits. The canonical case is
+     * `ALTER TYPE ... ADD VALUE`: using the new enum value in the same
+     * transaction fails with 55P04.
+     *
+     * This is a conservative boundary signal: the planner groups consecutive
+     * producers of the same kind into one unit, and pushes any other statement
+     * (different kind or non-producer) past a commit boundary, regardless of
+     * whether it references the produced effects. No consumer detection is
+     * attempted. Never derive this from the rendered SQL — declare it on the
+     * change class.
+     *
+     * Defaults to null. Override in subclasses whose effects PostgreSQL defers
+     * until commit.
      */
-    get changeId(): string;
+    get commitBoundary(): CommitBoundaryReason | null;
     /**
      * Stable identifiers this change creates.
      *
@@ -28,6 +76,18 @@ export declare abstract class BaseChange {
      * Defaults to an empty array. Override in subclasses that remove objects.
      */
     get drops(): string[];
+    /**
+     * Stable identifiers this change invalidates in place.
+     *
+     * Unlike `drops`, the object keeps its identity. This is an ordering-only
+     * signal for mutations that rewrite an existing object in a way that requires
+     * dependents bound to the old definition to be dropped before the mutation
+     * and rebuilt afterward.
+     *
+     * Defaults to an empty array. Override in subclasses that invalidate
+     * dependents without dropping the object.
+     */
+    get invalidates(): string[];
     /**
      * Stable identifiers this change requires to exist beforehand.
      *
@@ -37,7 +97,7 @@ export declare abstract class BaseChange {
     /**
      * Serialize the change into a single SQL statement.
      */
-    abstract serialize(options?: Record<string, unknown>): string;
+    abstract serialize(options?: SerializeOptions): string;
 }
 /**
  * Port of string literal quoting: doubles single quotes inside and wraps with single quotes

package/dist/core/objects/base.change.js

@@ -1,9 +1,48 @@
+/**
+ * Abstract base class for all change objects.
+ *
+ * Every concrete change (e.g. `CreateTable`, `AlterView`) extends this class and
+ * provides an `operation`, `objectType`, and `scope`. The filter DSL flattens
+ * these properties — along with the model sub-object — into path/value pairs
+ * for pattern matching.
+ *
+ * @category Base
+ */
 export class BaseChange {
     /**
-     * A unique identifier for the change.
+     * True when the serialized statement cannot run inside a transaction block
+     * (PostgreSQL rejects it with SQLSTATE 25001, e.g. `CREATE INDEX
+     * CONCURRENTLY`, `CREATE SUBSCRIPTION` with `connect = true`).
+     *
+     * The planner emits such a change as its own single-statement migration
+     * unit with `transactionMode: "none"`, and `applyPlan` executes it without
+     * a `BEGIN`/`COMMIT` wrapper. Never derive this from the rendered SQL —
+     * declare it on the change class.
+     *
+     * Defaults to false. Override in subclasses whose statement PostgreSQL
+     * forbids inside a transaction block.
      */
-    get changeId() {
-        return `${this.operation}:${this.scope}:${this.objectType}:${this.serialize()}`;
+    get nonTransactional() {
+        return false;
+    }
+    /**
+     * Non-null when this statement's effects only become usable by later
+     * statements after the enclosing transaction commits. The canonical case is
+     * `ALTER TYPE ... ADD VALUE`: using the new enum value in the same
+     * transaction fails with 55P04.
+     *
+     * This is a conservative boundary signal: the planner groups consecutive
+     * producers of the same kind into one unit, and pushes any other statement
+     * (different kind or non-producer) past a commit boundary, regardless of
+     * whether it references the produced effects. No consumer detection is
+     * attempted. Never derive this from the rendered SQL — declare it on the
+     * change class.
+     *
+     * Defaults to null. Override in subclasses whose effects PostgreSQL defers
+     * until commit.
+     */
+    get commitBoundary() {
+        return null;
     }
     /**
      * Stable identifiers this change creates.
@@ -21,6 +60,20 @@ export class BaseChange {
     get drops() {
         return [];
     }
+    /**
+     * Stable identifiers this change invalidates in place.
+     *
+     * Unlike `drops`, the object keeps its identity. This is an ordering-only
+     * signal for mutations that rewrite an existing object in a way that requires
+     * dependents bound to the old definition to be dropped before the mutation
+     * and rebuilt afterward.
+     *
+     * Defaults to an empty array. Override in subclasses that invalidate
+     * dependents without dropping the object.
+     */
+    get invalidates() {
+        return [];
+    }
     /**
      * Stable identifiers this change requires to exist beforehand.
      *

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

@@ -16,6 +16,10 @@ export declare const columnPropsSchema: z.ZodObject<{
     collation: z.ZodNullable<z.ZodString>;
     default: z.ZodNullable<z.ZodString>;
     comment: z.ZodNullable<z.ZodString>;
+    security_labels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        label: z.ZodString;
+    }, z.z.core.$strip>>>;
 }, z.z.core.$strip>;
 export type ColumnProps = z.infer<typeof columnPropsSchema>;
 export declare function normalizeColumns(columns: ColumnProps[]): {
@@ -34,6 +38,10 @@ export declare function normalizeColumns(columns: ColumnProps[]): {
     collation: string | null;
     default: string | null;
     comment: string | null;
+    security_labels?: {
+        provider: string;
+        label: string;
+    }[] | undefined;
 }[];
 /**
  * Interface for table-like objects that have columns (tables, views, materialized views).
@@ -60,7 +68,10 @@ export declare abstract class BasePgModel {
      */
     abstract get dataFields(): Record<string, unknown>;
     /**
-     * Compare this object with another BasePgModel for equality based on stableId and dataFields.
+     * Compare this object with another BasePgModel for equality based on the stableId and
+     * the data portion of the stable snapshot. By default, the snapshot's `data` comes
+     * from {@link dataFields}, but subclasses may override {@link stableSnapshot} to
+     * normalize or otherwise transform the data used for equality.
      */
     equals(other: BasePgModel): boolean;
     /**

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

@@ -1,4 +1,5 @@
 import z from "zod";
+import { securityLabelPropsSchema } from "./security-label.types.js";
 import { deepEqual } from "./utils.js";
 export const columnPropsSchema = z.object({
     name: z.string(),
@@ -17,6 +18,7 @@ export const columnPropsSchema = z.object({
     collation: z.string().nullable(),
     default: z.string().nullable(),
     comment: z.string().nullable(),
+    security_labels: z.array(securityLabelPropsSchema).optional(),
 });
 export function normalizeColumns(columns) {
     return columns
@@ -28,11 +30,14 @@ export function normalizeColumns(columns) {
 }
 export class BasePgModel {
     /**
-     * Compare this object with another BasePgModel for equality based on stableId and dataFields.
+     * Compare this object with another BasePgModel for equality based on the stableId and
+     * the data portion of the stable snapshot. By default, the snapshot's `data` comes
+     * from {@link dataFields}, but subclasses may override {@link stableSnapshot} to
+     * normalize or otherwise transform the data used for equality.
      */
     equals(other) {
         return (this.stableId === other.stableId &&
-            deepEqual(this.dataFields, other.dataFields));
+            deepEqual(this.stableSnapshot().data, other.stableSnapshot().data));
     }
     /**
      * Stable representation used for equality/fingerprints.