@supabase/pg-delta 1.0.0-alpha.25 → 1.0.0-alpha.27

package/src/core/objects/foreign-data-wrapper/server/server.model.ts

@@ -26,6 +26,9 @@ const serverPropsSchema = z.object({
   options: z.array(z.string()).nullable(),
   comment: z.string().nullable(),
   privileges: z.array(privilegePropsSchema),
+  // Parent FDW handler/validator — filter metadata only, not in dataFields.
+  wrapper_handler: z.string().nullable().optional(),
+  wrapper_validator: z.string().nullable().optional(),
 });
 
 type ServerPrivilegeProps = PrivilegeProps;
@@ -40,6 +43,8 @@ export class Server extends BasePgModel {
   public readonly options: ServerProps["options"];
   public readonly comment: ServerProps["comment"];
   public readonly privileges: ServerPrivilegeProps[];
+  public readonly wrapper_handler: ServerProps["wrapper_handler"];
+  public readonly wrapper_validator: ServerProps["wrapper_validator"];
 
   constructor(props: ServerProps) {
     super();
@@ -55,6 +60,8 @@ export class Server extends BasePgModel {
     this.options = props.options;
     this.comment = props.comment;
     this.privileges = props.privileges;
+    this.wrapper_handler = props.wrapper_handler ?? null;
+    this.wrapper_validator = props.wrapper_validator ?? null;
   }
 
   get stableId(): `server:${string}` {
@@ -112,10 +119,20 @@ export async function extractServers(pool: Pool): Promise<Server[]> {
             )
             from lateral aclexplode(srv.srvacl) as x(grantor, grantee, privilege_type, is_grantable)
           ), '[]'
-        ) as privileges
+        ) as privileges,
+        case
+          when fdw.fdwhandler = 0 then null
+          else p_handler.pronamespace::regnamespace::text || '.' || quote_ident(p_handler.proname)
+        end as wrapper_handler,
+        case
+          when fdw.fdwvalidator = 0 then null
+          else p_validator.pronamespace::regnamespace::text || '.' || quote_ident(p_validator.proname)
+        end as wrapper_validator
       from
         pg_catalog.pg_foreign_server srv
         inner join pg_catalog.pg_foreign_data_wrapper fdw on fdw.oid = srv.srvfdw
+        left join pg_catalog.pg_proc p_handler on p_handler.oid = fdw.fdwhandler
+        left join pg_catalog.pg_proc p_validator on p_validator.oid = fdw.fdwvalidator
       where
         not fdw.fdwname like any(array['pg\\_%'])
       order by

package/src/core/objects/foreign-data-wrapper/user-mapping/changes/user-mapping.base.ts

@@ -4,7 +4,7 @@ import type { UserMapping } from "../user-mapping.model.ts";
 abstract class BaseUserMappingChange extends BaseChange {
   abstract readonly userMapping: UserMapping;
   abstract readonly scope: "object";
-  readonly objectType: "user_mapping" = "user_mapping";
+  readonly objectType = "user_mapping" as const;
 }
 
 export abstract class CreateUserMappingChange extends BaseUserMappingChange {

package/src/core/objects/foreign-data-wrapper/user-mapping/user-mapping.model.ts

@@ -18,6 +18,9 @@ const userMappingPropsSchema = z.object({
   user: z.string(),
   server: z.string(),
   options: z.array(z.string()).nullable(),
+  // Parent FDW handler/validator — filter metadata only, not in dataFields.
+  wrapper_handler: z.string().nullable().optional(),
+  wrapper_validator: z.string().nullable().optional(),
 });
 
 export type UserMappingProps = z.infer<typeof userMappingPropsSchema>;
@@ -26,6 +29,8 @@ export class UserMapping extends BasePgModel {
   public readonly user: UserMappingProps["user"];
   public readonly server: UserMappingProps["server"];
   public readonly options: UserMappingProps["options"];
+  public readonly wrapper_handler: UserMappingProps["wrapper_handler"];
+  public readonly wrapper_validator: UserMappingProps["wrapper_validator"];
 
   constructor(props: UserMappingProps) {
     super();
@@ -36,6 +41,8 @@ export class UserMapping extends BasePgModel {
 
     // Data fields
     this.options = props.options;
+    this.wrapper_handler = props.wrapper_handler ?? null;
+    this.wrapper_validator = props.wrapper_validator ?? null;
   }
 
   get stableId(): `userMapping:${string}:${string}` {
@@ -74,11 +81,21 @@ export async function extractUserMappings(pool: Pool): Promise<UserMapping[]> {
           else um.umuser::regrole::text
         end as user,
         quote_ident(srv.srvname) as server,
-        coalesce(um.umoptions, array[]::text[]) as options
+        coalesce(um.umoptions, array[]::text[]) as options,
+        case
+          when fdw.fdwhandler = 0 then null
+          else p_handler.pronamespace::regnamespace::text || '.' || quote_ident(p_handler.proname)
+        end as wrapper_handler,
+        case
+          when fdw.fdwvalidator = 0 then null
+          else p_validator.pronamespace::regnamespace::text || '.' || quote_ident(p_validator.proname)
+        end as wrapper_validator
       from
         pg_catalog.pg_user_mapping um
         inner join pg_catalog.pg_foreign_server srv on srv.oid = um.umserver
         inner join pg_catalog.pg_foreign_data_wrapper fdw on fdw.oid = srv.srvfdw
+        left join pg_catalog.pg_proc p_handler on p_handler.oid = fdw.fdwhandler
+        left join pg_catalog.pg_proc p_validator on p_validator.oid = fdw.fdwvalidator
       where
         not fdw.fdwname like any(array['pg\\_%'])
       order by

package/src/core/objects/index/changes/index.base.ts

@@ -4,7 +4,7 @@ import type { Index } from "../index.model.ts";
 abstract class BaseIndexChange extends BaseChange {
   abstract readonly index: Index;
   abstract readonly scope: "object" | "comment";
-  readonly objectType: "index" = "index";
+  readonly objectType = "index" as const;
 }
 
 export abstract class CreateIndexChange extends BaseIndexChange {

package/src/core/objects/language/changes/language.base.ts

@@ -4,7 +4,7 @@ import type { Language } from "../language.model.ts";
 abstract class BaseLanguageChange extends BaseChange {
   abstract readonly language: Language;
   abstract readonly scope: "object" | "comment" | "privilege";
-  readonly objectType: "language" = "language";
+  readonly objectType = "language" as const;
 }
 
 export abstract class CreateLanguageChange extends BaseLanguageChange {

package/src/core/objects/materialized-view/changes/materialized-view.base.ts

@@ -8,7 +8,7 @@ abstract class BaseMaterializedViewChange extends BaseChange {
     | "comment"
     | "privilege"
     | "security_label";
-  readonly objectType: "materialized_view" = "materialized_view";
+  readonly objectType = "materialized_view" as const;
 }
 
 export abstract class CreateMaterializedViewChange extends BaseMaterializedViewChange {

package/src/core/objects/procedure/changes/procedure.base.ts

@@ -8,7 +8,7 @@ abstract class BaseProcedureChange extends BaseChange {
     | "comment"
     | "privilege"
     | "security_label";
-  readonly objectType: "procedure" = "procedure";
+  readonly objectType = "procedure" as const;
 }
 
 export abstract class CreateProcedureChange extends BaseProcedureChange {

package/src/core/objects/rls-policy/changes/rls-policy.base.ts

@@ -4,7 +4,7 @@ import type { RlsPolicy } from "../rls-policy.model.ts";
 abstract class BaseRlsPolicyChange extends BaseChange {
   abstract readonly policy: RlsPolicy;
   abstract readonly scope: "object" | "comment";
-  readonly objectType: "rls_policy" = "rls_policy";
+  readonly objectType = "rls_policy" as const;
 }
 
 export abstract class CreateRlsPolicyChange extends BaseRlsPolicyChange {

package/src/core/objects/role/changes/role.base.ts

@@ -9,7 +9,7 @@ abstract class BaseRoleChange extends BaseChange {
     | "membership"
     | "default_privilege"
     | "security_label";
-  readonly objectType: "role" = "role";
+  readonly objectType = "role" as const;
 }
 
 export abstract class CreateRoleChange extends BaseRoleChange {

package/src/core/objects/schema/changes/schema.base.ts

@@ -8,7 +8,7 @@ abstract class BaseSchemaChange extends BaseChange {
     | "comment"
     | "privilege"
     | "security_label";
-  readonly objectType: "schema" = "schema";
+  readonly objectType = "schema" as const;
 }
 
 export abstract class CreateSchemaChange extends BaseSchemaChange {

package/src/core/objects/sequence/changes/sequence.base.ts

@@ -8,7 +8,7 @@ abstract class BaseSequenceChange extends BaseChange {
     | "comment"
     | "privilege"
     | "security_label";
-  readonly objectType: "sequence" = "sequence";
+  readonly objectType = "sequence" as const;
 }
 
 export abstract class CreateSequenceChange extends BaseSequenceChange {

package/src/core/objects/table/changes/table.base.ts

@@ -8,7 +8,7 @@ abstract class BaseTableChange extends BaseChange {
     | "comment"
     | "privilege"
     | "security_label";
-  readonly objectType: "table" = "table";
+  readonly objectType = "table" as const;
 }
 
 export abstract class CreateTableChange extends BaseTableChange {

package/src/core/objects/table/changes/table.comment.ts

@@ -179,10 +179,7 @@ export class CreateCommentOnConstraint extends CreateTableChange {
   public readonly constraint: TableConstraintProps;
   public readonly scope = "comment" as const;
 
-  constructor(props: {
-    table: Table;
-    constraint: TableConstraintProps;
-  }) {
+  constructor(props: { table: Table; constraint: TableConstraintProps }) {
     super();
     this.table = props.table;
     this.constraint = props.constraint;
@@ -228,10 +225,7 @@ export class DropCommentOnConstraint extends DropTableChange {
   public readonly constraint: TableConstraintProps;
   public readonly scope = "comment" as const;
 
-  constructor(props: {
-    table: Table;
-    constraint: TableConstraintProps;
-  }) {
+  constructor(props: { table: Table; constraint: TableConstraintProps }) {
     super();
     this.table = props.table;
     this.constraint = props.constraint;

package/src/core/objects/table/table.diff.test.ts

@@ -75,7 +75,7 @@ describe.concurrent("table.diff", () => {
     expect(dropped[0]).toBeInstanceOf(DropTable);
   });
 
-  test("created NOT VALID CHECK emits AddConstraint + ValidateConstraint", () => {
+  test("created NOT VALID CHECK emits AddConstraint only (no Validate)", () => {
     const main = new Table({
       ...base,
       name: "t_nv",
@@ -102,6 +102,7 @@ describe.concurrent("table.diff", () => {
       constraints: [],
     });
     const branch = new Table({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...main,
       constraints: [
         {
@@ -132,20 +133,208 @@ describe.concurrent("table.diff", () => {
           match_type: null,
           check_expression: "a > 0",
           owner: "o1",
+          definition: "CHECK (a > 0) NOT VALID",
+        },
+      ],
+    });
+    const changes = diffTables(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    const add = changes.find((c) => c instanceof AlterTableAddConstraint);
+    expect(add).toBeInstanceOf(AlterTableAddConstraint);
+    expect(add?.serialize()).toContain("NOT VALID");
+    expect(changes.some((c) => c instanceof AlterTableValidateConstraint)).toBe(
+      false,
+    );
+  });
+
+  test("NOT VALID -> validated emits only VALIDATE CONSTRAINT (no drop+add)", () => {
+    const sharedConstraint = {
+      name: "ck_nv",
+      constraint_type: "c" as const,
+      deferrable: false,
+      initially_deferred: false,
+      is_local: true,
+      no_inherit: false,
+      is_temporal: false,
+      is_partition_clone: false,
+      parent_constraint_schema: null,
+      parent_constraint_name: null,
+      parent_table_schema: null,
+      parent_table_name: null,
+      key_columns: [],
+      foreign_key_columns: null,
+      foreign_key_table: null,
+      foreign_key_schema: null,
+      foreign_key_table_is_partition: null,
+      foreign_key_parent_schema: null,
+      foreign_key_parent_table: null,
+      foreign_key_effective_schema: null,
+      foreign_key_effective_table: null,
+      on_update: null,
+      on_delete: null,
+      match_type: null,
+      check_expression: "a > 0",
+      owner: "o1",
+      comment: null,
+    };
+
+    const main = new Table({
+      ...base,
+      name: "t_nv",
+      columns: [
+        {
+          name: "a",
+          position: 1,
+          data_type: "integer",
+          data_type_str: "integer",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+      constraints: [
+        {
+          ...sharedConstraint,
+          validated: false,
+          definition: "CHECK (a > 0) NOT VALID",
+        },
+      ],
+    });
+    const branch = new Table({
+      // oxlint-disable-next-line typescript/no-misused-spread
+      ...main,
+      constraints: [
+        {
+          ...sharedConstraint,
+          validated: true,
           definition: "CHECK (a > 0)",
         },
       ],
     });
+
+    const changes = diffTables(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+
+    const validate = changes.find(
+      (c) => c instanceof AlterTableValidateConstraint,
+    );
+    expect(validate).toBeInstanceOf(AlterTableValidateConstraint);
+    expect(validate?.serialize()).toMatchInlineSnapshot(
+      `"ALTER TABLE public.t_nv VALIDATE CONSTRAINT ck_nv"`,
+    );
+
+    expect(changes.some((c) => c instanceof AlterTableDropConstraint)).toBe(
+      false,
+    );
+    expect(changes.some((c) => c instanceof AlterTableAddConstraint)).toBe(
+      false,
+    );
+  });
+
+  test("NOT VALID -> validated + other field change still drops+adds (no shortcut)", () => {
+    const sharedConstraint = {
+      name: "ck_nv",
+      constraint_type: "c" as const,
+      deferrable: false,
+      initially_deferred: false,
+      is_local: true,
+      no_inherit: false,
+      is_temporal: false,
+      is_partition_clone: false,
+      parent_constraint_schema: null,
+      parent_constraint_name: null,
+      parent_table_schema: null,
+      parent_table_name: null,
+      key_columns: [],
+      foreign_key_columns: null,
+      foreign_key_table: null,
+      foreign_key_schema: null,
+      foreign_key_table_is_partition: null,
+      foreign_key_parent_schema: null,
+      foreign_key_parent_table: null,
+      foreign_key_effective_schema: null,
+      foreign_key_effective_table: null,
+      on_update: null,
+      on_delete: null,
+      match_type: null,
+      owner: "o1",
+      comment: null,
+    };
+
+    const main = new Table({
+      ...base,
+      name: "t_nv",
+      columns: [
+        {
+          name: "a",
+          position: 1,
+          data_type: "integer",
+          data_type_str: "integer",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+      constraints: [
+        {
+          ...sharedConstraint,
+          validated: false,
+          check_expression: "a > 0",
+          definition: "CHECK (a > 0) NOT VALID",
+        },
+      ],
+    });
+    const branch = new Table({
+      // oxlint-disable-next-line typescript/no-misused-spread
+      ...main,
+      constraints: [
+        {
+          ...sharedConstraint,
+          validated: true,
+          check_expression: "a > 1",
+          definition: "CHECK (a > 1)",
+        },
+      ],
+    });
+
     const changes = diffTables(
       testContext,
       { [main.stableId]: main },
       { [branch.stableId]: branch },
     );
+
+    expect(changes.some((c) => c instanceof AlterTableDropConstraint)).toBe(
+      true,
+    );
     expect(changes.some((c) => c instanceof AlterTableAddConstraint)).toBe(
       true,
     );
     expect(changes.some((c) => c instanceof AlterTableValidateConstraint)).toBe(
-      true,
+      false,
     );
   });
 
@@ -362,7 +551,7 @@ describe.concurrent("table.diff", () => {
       true,
     );
     expect(created.some((c) => c instanceof AlterTableValidateConstraint)).toBe(
-      true,
+      false,
     );
 
     const dropped = diffTables(
@@ -480,6 +669,7 @@ describe.concurrent("table.diff", () => {
       ],
     });
     const tBranch = new Table({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...tMain,
       constraints: [
         {
@@ -501,7 +691,7 @@ describe.concurrent("table.diff", () => {
     );
   });
 
-  test("altered foreign key properties triggers drop+add and validate when not validated", () => {
+  test("altered foreign key to NOT VALID triggers drop+add without validate", () => {
     const tMain = new Table({
       ...base,
       name: "t_fk",
@@ -559,12 +749,14 @@ describe.concurrent("table.diff", () => {
       ],
     });
     const tBranch = new Table({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...tMain,
       constraints: [
         {
           ...(tMain.constraints[0] as (typeof tMain.constraints)[number]),
           on_delete: "c",
           validated: false,
+          definition: "FOREIGN KEY (a) REFERENCES other(a) NOT VALID",
         },
       ],
     });
@@ -606,7 +798,7 @@ describe.concurrent("table.diff", () => {
       true,
     );
     expect(changes.some((c) => c instanceof AlterTableValidateConstraint)).toBe(
-      true,
+      false,
     );
   });
 
@@ -686,6 +878,7 @@ describe.concurrent("table.diff", () => {
       ],
     });
     const tBranch = new Table({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...tMain,
       constraints: [
         {

package/src/core/objects/table/table.diff.ts

@@ -86,14 +86,6 @@ function createAlterConstraintChange(mainTable: Table, branchTable: Table) {
           constraint: c,
         }),
       );
-      if (!c.validated) {
-        changes.push(
-          new AlterTableValidateConstraint({
-            table: branchTable,
-            constraint: c,
-          }),
-        );
-      }
       // Add comment for newly created constraint
       if (c.comment !== null) {
         changes.push(
@@ -120,7 +112,7 @@ function createAlterConstraintChange(mainTable: Table, branchTable: Table) {
     }
   }
 
-  // Altered constraints -> drop + add
+  // Altered constraints -> drop + add (or VALIDATE-only shortcut)
   for (const [name, mainC] of mainByName) {
     const branchC = branchByName.get(name);
     if (!branchC) continue;
@@ -130,24 +122,68 @@ function createAlterConstraintChange(mainTable: Table, branchTable: Table) {
       continue;
     }
 
+    // Cheap scalar `===` checks first; only fall through to JSON.stringify
+    // on the array fields when every scalar has already matched.
+    const fieldsEqualExceptValidated =
+      mainC.constraint_type === branchC.constraint_type &&
+      mainC.deferrable === branchC.deferrable &&
+      mainC.initially_deferred === branchC.initially_deferred &&
+      mainC.is_local === branchC.is_local &&
+      mainC.no_inherit === branchC.no_inherit &&
+      mainC.is_temporal === branchC.is_temporal &&
+      mainC.foreign_key_table === branchC.foreign_key_table &&
+      mainC.foreign_key_schema === branchC.foreign_key_schema &&
+      mainC.on_update === branchC.on_update &&
+      mainC.on_delete === branchC.on_delete &&
+      mainC.match_type === branchC.match_type &&
+      mainC.check_expression === branchC.check_expression &&
+      JSON.stringify(mainC.key_columns) ===
+        JSON.stringify(branchC.key_columns) &&
+      JSON.stringify(mainC.foreign_key_columns) ===
+        JSON.stringify(branchC.foreign_key_columns);
+
+    // Safe-migration shortcut: when the only difference is `validated`
+    // flipping from false to true, emit a single `ALTER TABLE ... VALIDATE
+    // CONSTRAINT` instead of drop+add. VALIDATE CONSTRAINT only takes
+    // SHARE UPDATE EXCLUSIVE (concurrent reads/writes proceed), whereas
+    // dropping and re-adding takes ACCESS EXCLUSIVE for the entire scan.
+    // Postgres has no reverse command, so `true -> false` must still go
+    // through drop+add below.
+    if (
+      fieldsEqualExceptValidated &&
+      mainC.validated === false &&
+      branchC.validated === true
+    ) {
+      changes.push(
+        new AlterTableValidateConstraint({
+          table: branchTable,
+          constraint: branchC,
+        }),
+      );
+      // VALIDATE preserves the constraint OID, so its comment is preserved
+      // too. Only emit a comment change if it actually differs.
+      if (mainC.comment !== branchC.comment) {
+        if (branchC.comment === null) {
+          changes.push(
+            new DropCommentOnConstraint({
+              table: mainTable,
+              constraint: mainC,
+            }),
+          );
+        } else {
+          changes.push(
+            new CreateCommentOnConstraint({
+              table: branchTable,
+              constraint: branchC,
+            }),
+          );
+        }
+      }
+      continue;
+    }
+
     const changed =
-      mainC.constraint_type !== branchC.constraint_type ||
-      mainC.deferrable !== branchC.deferrable ||
-      mainC.initially_deferred !== branchC.initially_deferred ||
-      mainC.validated !== branchC.validated ||
-      mainC.is_local !== branchC.is_local ||
-      mainC.no_inherit !== branchC.no_inherit ||
-      mainC.is_temporal !== branchC.is_temporal ||
-      JSON.stringify(mainC.key_columns) !==
-        JSON.stringify(branchC.key_columns) ||
-      JSON.stringify(mainC.foreign_key_columns) !==
-        JSON.stringify(branchC.foreign_key_columns) ||
-      mainC.foreign_key_table !== branchC.foreign_key_table ||
-      mainC.foreign_key_schema !== branchC.foreign_key_schema ||
-      mainC.on_update !== branchC.on_update ||
-      mainC.on_delete !== branchC.on_delete ||
-      mainC.match_type !== branchC.match_type ||
-      mainC.check_expression !== branchC.check_expression;
+      mainC.validated !== branchC.validated || !fieldsEqualExceptValidated;
     if (changed) {
       changes.push(
         new AlterTableDropConstraint({
@@ -161,14 +197,6 @@ function createAlterConstraintChange(mainTable: Table, branchTable: Table) {
           constraint: branchC,
         }),
       );
-      if (!branchC.validated) {
-        changes.push(
-          new AlterTableValidateConstraint({
-            table: branchTable,
-            constraint: branchC,
-          }),
-        );
-      }
       // Ensure constraint comment is applied after re-creation
       if (branchC.comment !== null) {
         changes.push(
@@ -265,6 +293,7 @@ export function diffTables(
       ...createAlterConstraintChange(
         // Create a dummy table with no constraints do diff constraints against
         new Table({
+          // oxlint-disable-next-line typescript/no-misused-spread
           ...branchTable,
           constraints: [],
         }),

package/src/core/objects/trigger/changes/trigger.alter.ts

@@ -28,10 +28,7 @@ export class ReplaceTrigger extends AlterTriggerChange {
   public readonly indexableObject?: TableLikeObject;
   public readonly scope = "object" as const;
 
-  constructor(props: {
-    trigger: Trigger;
-    indexableObject?: TableLikeObject;
-  }) {
+  constructor(props: { trigger: Trigger; indexableObject?: TableLikeObject }) {
     super();
     this.trigger = props.trigger;
     this.indexableObject = props.indexableObject;

package/src/core/objects/trigger/changes/trigger.base.ts

@@ -4,7 +4,7 @@ import type { Trigger } from "../trigger.model.ts";
 abstract class BaseTriggerChange extends BaseChange {
   abstract readonly trigger: Trigger;
   abstract readonly scope: "object" | "comment";
-  readonly objectType: "trigger" = "trigger";
+  readonly objectType = "trigger" as const;
 }
 
 export abstract class CreateTriggerChange extends BaseTriggerChange {

package/src/core/objects/type/composite-type/changes/composite-type.base.ts

@@ -8,7 +8,7 @@ abstract class BaseCompositeTypeChange extends BaseChange {
     | "comment"
     | "privilege"
     | "security_label";
-  readonly objectType: "composite_type" = "composite_type";
+  readonly objectType = "composite_type" as const;
 }
 
 export abstract class CreateCompositeTypeChange extends BaseCompositeTypeChange {

package/src/core/objects/type/enum/changes/enum.base.ts

@@ -8,7 +8,7 @@ abstract class BaseEnumChange extends BaseChange {
     | "comment"
     | "privilege"
     | "security_label";
-  readonly objectType: "enum" = "enum";
+  readonly objectType = "enum" as const;
 }
 
 export abstract class CreateEnumChange extends BaseEnumChange {