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

package/src/core/integrations/supabase.test.ts

@@ -55,6 +55,86 @@ function fdwPrivilegeChange(fdw: { name: string; owner: string }): Change {
   } as unknown as Change;
 }
 
+function serverChange(
+  operation: "create" | "alter" | "drop",
+  server: {
+    name: string;
+    owner: string;
+    foreign_data_wrapper: string;
+    wrapper_handler: string | null;
+    wrapper_validator: string | null;
+  },
+): Change {
+  return {
+    objectType: "server",
+    operation,
+    scope: "object",
+    server: {
+      type: null,
+      version: null,
+      options: null,
+      comment: null,
+      privileges: [],
+      ...server,
+    },
+    requires: [],
+    creates: [],
+    drops: [],
+  } as unknown as Change;
+}
+
+function foreignTableChange(
+  operation: "create" | "alter" | "drop",
+  foreignTable: {
+    schema: string;
+    name: string;
+    owner: string;
+    server: string;
+    wrapper_handler: string | null;
+    wrapper_validator: string | null;
+  },
+): Change {
+  return {
+    objectType: "foreign_table",
+    operation,
+    scope: "object",
+    foreignTable: {
+      options: null,
+      comment: null,
+      columns: [],
+      privileges: [],
+      security_labels: [],
+      ...foreignTable,
+    },
+    requires: [],
+    creates: [],
+    drops: [],
+  } as unknown as Change;
+}
+
+function userMappingChange(
+  operation: "create" | "alter" | "drop",
+  userMapping: {
+    user: string;
+    server: string;
+    wrapper_handler: string | null;
+    wrapper_validator: string | null;
+  },
+): Change {
+  return {
+    objectType: "user_mapping",
+    operation,
+    scope: "object",
+    userMapping: {
+      options: null,
+      ...userMapping,
+    },
+    requires: [],
+    creates: [],
+    drops: [],
+  } as unknown as Change;
+}
+
 function serverPrivilegeChange(server: {
   name: string;
   owner: string;
@@ -71,6 +151,33 @@ function serverPrivilegeChange(server: {
   } as unknown as Change;
 }
 
+/**
+ * Build a synthetic trigger change shaped like what `flattenChange` consumes.
+ * The flattener emits keys `trigger/schema`, `trigger/table_name`,
+ * `trigger/function_schema`, etc. by walking the nested `trigger` model.
+ */
+function triggerChange(
+  operation: "create" | "alter" | "drop",
+  trigger: {
+    schema: string;
+    name: string;
+    table_name: string;
+    function_schema: string;
+    function_name: string;
+    owner: string;
+  },
+): Change {
+  return {
+    objectType: "trigger",
+    operation,
+    scope: "object",
+    trigger,
+    requires: [],
+    creates: [],
+    drops: [],
+  } as unknown as Change;
+}
+
 describe("supabase integration filter — foreign data wrappers", () => {
   // Regression for CLI-1470. Wasm-based foreign data wrappers on Supabase
   // (e.g. `clerk`, `clerk_oauth`) are provisioned at project creation by
@@ -128,6 +235,35 @@ describe("supabase integration filter — foreign data wrappers", () => {
     expect(evaluatePattern(filter, change)).toBe(true);
   });
 
+  // `postgres_fdw` (and other contrib FDWs) install their handler/validator
+  // into `extensions` on Supabase, but they ARE available in the local image,
+  // so a user-created `postgres_fdw` wrapper must roundtrip. Only the Wasm
+  // `wasm_fdw_handler` / `wasm_fdw_validator` functions identify the
+  // platform-managed wrappers that local Docker cannot provision.
+  test("preserves user FDW whose handler is extensions.postgres_fdw_handler", () => {
+    const change = fdwChange("create", {
+      name: "postgres_fdw",
+      owner: "postgres",
+      handler: "extensions.postgres_fdw_handler",
+      validator: "extensions.postgres_fdw_validator",
+    });
+    expect(evaluatePattern(filter, change)).toBe(true);
+  });
+
+  // The Wasm discriminator must be an exact function-name match, not a
+  // prefix: a user function whose name merely starts with `wasm_fdw_handler`
+  // (e.g. `wasm_fdw_handler_custom`) is not the platform `wrappers` handler
+  // and must roundtrip.
+  test("preserves user FDW whose handler extends the wasm_fdw_handler prefix", () => {
+    const change = fdwChange("create", {
+      name: "custom_wasm",
+      owner: "postgres",
+      handler: "extensions.wasm_fdw_handler_custom",
+      validator: "extensions.wasm_fdw_validator_custom",
+    });
+    expect(evaluatePattern(filter, change)).toBe(true);
+  });
+
   test("preserves user FDW with no handler/validator", () => {
     const change = fdwChange("create", {
       name: "user_fdw_bare",
@@ -196,3 +332,202 @@ describe("supabase integration filter — foreign data wrapper / server ACLs", (
     expect(evaluatePattern(filter, change)).toBe(true);
   });
 });
+
+describe("supabase integration filter — Wasm FDW dependents", () => {
+  const wasmWrapper = {
+    wrapper_handler: "extensions.wasm_fdw_handler",
+    wrapper_validator: "extensions.wasm_fdw_validator",
+  } as const;
+
+  const userWrapper = {
+    wrapper_handler: "public.postgres_fdw_handler",
+    wrapper_validator: "public.postgres_fdw_validator",
+  } as const;
+
+  // `postgres_fdw` installs its handler/validator into `extensions` on
+  // Supabase, but the contrib FDW IS available locally, so user-owned
+  // servers / foreign tables / user mappings built on it must roundtrip.
+  // Keying suppression on the bare `extensions.*` namespace would wrongly
+  // drop them; only the Wasm `wasm_fdw_*` functions mark platform wrappers.
+  const extensionsPgFdwWrapper = {
+    wrapper_handler: "extensions.postgres_fdw_handler",
+    wrapper_validator: "extensions.postgres_fdw_validator",
+  } as const;
+
+  test("suppresses CREATE SERVER bound to extensions.* Wasm FDW", () => {
+    const change = serverChange("create", {
+      name: "clerk_oauth_server",
+      owner: "postgres",
+      foreign_data_wrapper: "clerk_oauth",
+      ...wasmWrapper,
+    });
+    expect(evaluatePattern(filter, change)).toBe(false);
+  });
+
+  test("suppresses DROP FOREIGN TABLE bound to extensions.* Wasm FDW", () => {
+    const change = foreignTableChange("drop", {
+      schema: "public",
+      name: "clerk_oauth",
+      owner: "postgres",
+      server: "clerk_oauth_server",
+      ...wasmWrapper,
+    });
+    expect(evaluatePattern(filter, change)).toBe(false);
+  });
+
+  test("suppresses ALTER FOREIGN TABLE bound to extensions.* Wasm FDW", () => {
+    const change = foreignTableChange("alter", {
+      schema: "public",
+      name: "clerk_oauth",
+      owner: "postgres",
+      server: "clerk_oauth_server",
+      ...wasmWrapper,
+    });
+    expect(evaluatePattern(filter, change)).toBe(false);
+  });
+
+  test("suppresses DROP USER MAPPING bound to extensions.* Wasm FDW", () => {
+    const change = userMappingChange("drop", {
+      user: "postgres",
+      server: "clerk_server",
+      ...wasmWrapper,
+    });
+    expect(evaluatePattern(filter, change)).toBe(false);
+  });
+
+  test("suppresses CREATE USER MAPPING when only wrapper validator is in extensions", () => {
+    const change = userMappingChange("create", {
+      user: "postgres",
+      server: "clerk_server",
+      wrapper_handler: null,
+      wrapper_validator: "extensions.wasm_fdw_validator",
+    });
+    expect(evaluatePattern(filter, change)).toBe(false);
+  });
+
+  test("preserves CREATE SERVER bound to user postgres_fdw wrapper", () => {
+    const change = serverChange("create", {
+      name: "live_risk_server",
+      owner: "postgres",
+      foreign_data_wrapper: "postgres_fdw",
+      ...userWrapper,
+    });
+    expect(evaluatePattern(filter, change)).toBe(true);
+  });
+
+  test("preserves server ACL when postgres_fdw handler lives in extensions", () => {
+    const change = serverPrivilegeChange({
+      name: "user_server",
+      owner: "postgres",
+    });
+    (change as unknown as { server: Record<string, unknown> }).server = {
+      name: "user_server",
+      owner: "postgres",
+      wrapper_handler: "extensions.postgres_fdw_handler",
+      wrapper_validator: "extensions.postgres_fdw_validator",
+    };
+    expect(evaluatePattern(filter, change)).toBe(true);
+  });
+
+  test("preserves CREATE FOREIGN TABLE on user postgres_fdw server", () => {
+    const change = foreignTableChange("create", {
+      schema: "live_risk",
+      name: "devices",
+      owner: "postgres",
+      server: "live_risk_server",
+      ...userWrapper,
+    });
+    expect(evaluatePattern(filter, change)).toBe(true);
+  });
+
+  test("preserves CREATE SERVER when postgres_fdw handler lives in extensions", () => {
+    const change = serverChange("create", {
+      name: "user_pg_server",
+      owner: "postgres",
+      foreign_data_wrapper: "postgres_fdw",
+      ...extensionsPgFdwWrapper,
+    });
+    expect(evaluatePattern(filter, change)).toBe(true);
+  });
+
+  test("preserves CREATE FOREIGN TABLE when postgres_fdw handler lives in extensions", () => {
+    const change = foreignTableChange("create", {
+      schema: "user_fdw_test",
+      name: "remote_row",
+      owner: "postgres",
+      server: "user_pg_server",
+      ...extensionsPgFdwWrapper,
+    });
+    expect(evaluatePattern(filter, change)).toBe(true);
+  });
+
+  test("preserves CREATE USER MAPPING when postgres_fdw handler lives in extensions", () => {
+    const change = userMappingChange("create", {
+      user: "postgres",
+      server: "user_pg_server",
+      ...extensionsPgFdwWrapper,
+    });
+    expect(evaluatePattern(filter, change)).toBe(true);
+  });
+
+  // Exact-match guard at the dependent level too: a server bound to a wrapper
+  // whose handler merely shares the `wasm_fdw_handler` prefix must roundtrip.
+  test("preserves CREATE SERVER when wrapper handler extends the wasm_fdw_handler prefix", () => {
+    const change = serverChange("create", {
+      name: "custom_wasm_server",
+      owner: "postgres",
+      foreign_data_wrapper: "custom_wasm",
+      wrapper_handler: "extensions.wasm_fdw_handler_custom",
+      wrapper_validator: "extensions.wasm_fdw_validator_custom",
+    });
+    expect(evaluatePattern(filter, change)).toBe(true);
+  });
+});
+
+describe("supabase integration filter — pgmq queue triggers", () => {
+  // Regression for the pgmq-1.4.4 cloud projects. `pgmq.create('<name>')`
+  // materializes `pgmq.q_<name>` and `pgmq.a_<name>` at runtime — they are
+  // NOT created by `CREATE EXTENSION pgmq`. On a healthy install the trigger
+  // extractor's `extension_table_oids` join already drops these via the
+  // `pg_depend deptype='e'` row that newer pgmq versions record, but on
+  // pgmq 1.4.4 that row is never recorded, so user triggers on the queue
+  // tables leak into the diff and break `supabase db reset` with
+  // `relation "pgmq.q_<name>" does not exist`. The filter must drop them
+  // at the supabase-integration level too, regardless of pg_depend state.
+
+  test("suppresses CREATE trigger on pgmq.q_<name> calling a public function", () => {
+    const change = triggerChange("create", {
+      schema: "pgmq",
+      name: "after_insert_processed_milestones_queue",
+      table_name: "q_processed_milestones_queue",
+      function_schema: "public",
+      function_name: "move_data_from_queue",
+      owner: "postgres",
+    });
+    expect(evaluatePattern(filter, change)).toBe(false);
+  });
+
+  test("suppresses DROP trigger on pgmq.a_<name> calling a public function", () => {
+    const change = triggerChange("drop", {
+      schema: "pgmq",
+      name: "after_insert_archive",
+      table_name: "a_processed_milestones_queue",
+      function_schema: "public",
+      function_name: "archive_handler",
+      owner: "postgres",
+    });
+    expect(evaluatePattern(filter, change)).toBe(false);
+  });
+
+  test("preserves CREATE trigger on auth.users calling a public function", () => {
+    const change = triggerChange("create", {
+      schema: "auth",
+      name: "on_auth_user_created",
+      table_name: "users",
+      function_schema: "public",
+      function_name: "handle_new_user",
+      owner: "supabase_auth_admin",
+    });
+    expect(evaluatePattern(filter, change)).toBe(true);
+  });
+});

package/src/core/integrations/supabase.ts

@@ -125,6 +125,30 @@ export const supabase: IntegrationDSL = {
               "trigger/function_schema": [...SUPABASE_SYSTEM_SCHEMAS],
             },
           },
+          // Defensive fallback for dynamically-created pgmq queue /
+          // archive tables. `pgmq.q_<name>` and `pgmq.a_<name>` are
+          // materialized by `select pgmq.create('<name>')`, NOT by
+          // `CREATE EXTENSION pgmq`, so emitting a user trigger against
+          // them fails locally with
+          // `relation "pgmq.q_<name>" does not exist`. On a healthy
+          // install the trigger extractor's `extension_table_oids` join
+          // (packages/pg-delta/src/core/objects/trigger/trigger.model.ts)
+          // already drops these via the `pg_depend deptype='e'` row pgmq
+          // records during `pgmq.create()`; this rule covers projects
+          // where that row is missing (older pgmq, manual table
+          // rewrites, `pg_dump`/restore that loses extension deps, ...).
+          // pgmq 1.4.4 — the version Supabase Cloud currently ships —
+          // does not record the dependency at all.
+          {
+            not: {
+              and: [
+                { "trigger/schema": "pgmq" },
+                {
+                  "trigger/table_name": { op: "regex", value: "^[qa]_" },
+                },
+              ],
+            },
+          },
         ],
       },
       // Exclude system objects
@@ -185,15 +209,25 @@ export const supabase: IntegrationDSL = {
               ],
             },
             // Platform-managed foreign data wrappers — Wasm-based FDWs
-            // (e.g. `clerk`, `clerk_oauth`) whose handler/validator live in
-            // the `extensions` schema. `CREATE FOREIGN DATA WRAPPER`
-            // requires superuser, and Supabase Cloud provisions these via
-            // `supabase_admin` at project creation; replaying the DDL
-            // against a local image fails because the local environment
-            // has no equivalent pre-step. We can't rely on the FDW owner
-            // alone — after a dump/restore the owner is often rewritten
-            // away from `supabase_admin` — so match on the function
-            // reference instead.
+            // (e.g. `clerk`, `clerk_oauth`) provisioned via the `wrappers`
+            // extension. Supabase Cloud creates these as
+            // `CREATE FOREIGN DATA WRAPPER clerk_oauth HANDLER
+            // extensions.wasm_fdw_handler VALIDATOR
+            // extensions.wasm_fdw_validator` at project creation; replaying
+            // the DDL against a local image fails because the local
+            // environment has no equivalent pre-step. We can't rely on the
+            // FDW owner alone — after a dump/restore the owner is often
+            // rewritten away from `supabase_admin` — so match on the shared
+            // Wasm handler/validator (`extensions.wasm_fdw_handler` /
+            // `extensions.wasm_fdw_validator`) instead.
+            //
+            // Matching the bare `extensions.*` namespace would be too broad:
+            // contrib FDWs like `postgres_fdw` also install their
+            // handler/validator into `extensions` on Supabase, and those ARE
+            // available in the local image, so a user-created `postgres_fdw`
+            // wrapper (and its servers/foreign tables/user mappings) must
+            // still roundtrip. Keying on the `wasm_fdw_*` function names
+            // targets only the platform Wasm wrappers.
             {
               and: [
                 { objectType: "foreign_data_wrapper" },
@@ -202,13 +236,70 @@ export const supabase: IntegrationDSL = {
                     {
                       "foreign_data_wrapper/handler": {
                         op: "regex",
-                        value: "^extensions\\.",
+                        value: "^extensions\\.wasm_fdw_handler$",
                       },
                     },
                     {
                       "foreign_data_wrapper/validator": {
                         op: "regex",
-                        value: "^extensions\\.",
+                        value: "^extensions\\.wasm_fdw_validator$",
+                      },
+                    },
+                  ],
+                },
+              ],
+            },
+            // Platform-managed Wasm FDW dependents (CLI-1470 follow-up).
+            // Suppressing the wrapper DDL alone leaves `CREATE SERVER` /
+            // `CREATE FOREIGN TABLE` / `CREATE USER MAPPING` that reference
+            // a wrapper local Docker never provisions (`clerk_oauth`, etc.).
+            // Match on the parent wrapper's Wasm handler/validator
+            // (`extensions.wasm_fdw_handler` / `extensions.wasm_fdw_validator`,
+            // joined at extract time) — the same discriminator used for the
+            // wrapper itself above. A bare `extensions.*` match would also
+            // drop user-created `postgres_fdw` servers/foreign tables/user
+            // mappings (whose handler installs into `extensions` but which
+            // the local image CAN provision), so keep it scoped to the Wasm
+            // function names. Server _privilege_ scope is excluded here —
+            // `GRANT/REVOKE ON SERVER` does not require superuser and remains
+            // user-declarative state (see CLI-1469 companion test).
+            {
+              and: [
+                { objectType: "server" },
+                { not: { scope: "privilege" } },
+                {
+                  or: [
+                    {
+                      "{server,foreign_table,user_mapping}/wrapper_handler": {
+                        op: "regex",
+                        value: "^extensions\\.wasm_fdw_handler$",
+                      },
+                    },
+                    {
+                      "{server,foreign_table,user_mapping}/wrapper_validator": {
+                        op: "regex",
+                        value: "^extensions\\.wasm_fdw_validator$",
+                      },
+                    },
+                  ],
+                },
+              ],
+            },
+            {
+              and: [
+                { objectType: ["foreign_table", "user_mapping"] },
+                {
+                  or: [
+                    {
+                      "{server,foreign_table,user_mapping}/wrapper_handler": {
+                        op: "regex",
+                        value: "^extensions\\.wasm_fdw_handler$",
+                      },
+                    },
+                    {
+                      "{server,foreign_table,user_mapping}/wrapper_validator": {
+                        op: "regex",
+                        value: "^extensions\\.wasm_fdw_validator$",
                       },
                     },
                   ],

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

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

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

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

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

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

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

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

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

@@ -4,7 +4,7 @@ import type { ForeignDataWrapper } from "../foreign-data-wrapper.model.ts";
 abstract class BaseForeignDataWrapperChange extends BaseChange {
   abstract readonly foreignDataWrapper: ForeignDataWrapper;
   abstract readonly scope: "object" | "comment" | "privilege";
-  readonly objectType: "foreign_data_wrapper" = "foreign_data_wrapper";
+  readonly objectType = "foreign_data_wrapper" as const;
 }
 
 export abstract class CreateForeignDataWrapperChange extends BaseForeignDataWrapperChange {

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

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

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

@@ -36,6 +36,9 @@ const foreignTablePropsSchema = z.object({
   columns: z.array(columnPropsSchema),
   privileges: z.array(privilegePropsSchema),
   security_labels: z.array(securityLabelPropsSchema).default([]).optional(),
+  // Parent FDW handler/validator — filter metadata only, not in dataFields.
+  wrapper_handler: z.string().nullable().optional(),
+  wrapper_validator: z.string().nullable().optional(),
 });
 
 type ForeignTablePrivilegeProps = PrivilegeProps;
@@ -51,6 +54,8 @@ export class ForeignTable extends BasePgModel implements TableLikeObject {
   public readonly columns: ForeignTableProps["columns"];
   public readonly privileges: ForeignTablePrivilegeProps[];
   public readonly security_labels: SecurityLabelProps[];
+  public readonly wrapper_handler: ForeignTableProps["wrapper_handler"];
+  public readonly wrapper_validator: ForeignTableProps["wrapper_validator"];
 
   constructor(props: ForeignTableProps) {
     super();
@@ -67,6 +72,8 @@ export class ForeignTable extends BasePgModel implements TableLikeObject {
     this.columns = props.columns;
     this.privileges = props.privileges;
     this.security_labels = props.security_labels ?? [];
+    this.wrapper_handler = props.wrapper_handler ?? null;
+    this.wrapper_validator = props.wrapper_validator ?? null;
   }
 
   get stableId(): `foreignTable:${string}` {
@@ -146,12 +153,22 @@ export async function extractForeignTables(
           c.relowner::regrole::text as owner,
           quote_ident(srv.srvname) as server,
           coalesce(ft.ftoptions, array[]::text[]) as options,
-          c.oid as oid
+          c.oid as oid,
+          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_class c
           inner join pg_foreign_table ft on ft.ftrelid = c.oid
           inner join pg_foreign_server srv on srv.oid = ft.ftserver
           inner join 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
           left outer join extension_oids e1 on c.oid = e1.objid
         where
           c.relkind = 'f'
@@ -165,6 +182,8 @@ export async function extractForeignTables(
         ft.owner,
         ft.server,
         ft.options,
+        ft.wrapper_handler,
+        ft.wrapper_validator,
         obj_description(ft.oid, 'pg_class') as comment,
         coalesce(json_agg(
           case when a.attname is not null then
@@ -250,7 +269,14 @@ export async function extractForeignTables(
         left join pg_attrdef ad on a.attrelid = ad.adrelid and a.attnum = ad.adnum
         left join pg_type ty on ty.oid = a.atttypid
       group by
-        ft.oid, ft.schema, ft.name, ft.owner, ft.server, ft.options
+        ft.oid,
+        ft.schema,
+        ft.name,
+        ft.owner,
+        ft.server,
+        ft.options,
+        ft.wrapper_handler,
+        ft.wrapper_validator
       order by
         ft.schema, ft.name
   `);

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

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