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

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

@@ -1,6 +1,7 @@
 import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../base.model.js";
+import { securityLabelPropsSchema, } from "../security-label.types.js";
 const membershipInfoSchema = z.object({
     member: z.string(),
     grantor: z.string(),
@@ -13,6 +14,7 @@ const defaultPrivilegeSchema = z.object({
     objtype: z.enum(["r", "S", "f", "T", "n"]),
     grantee: z.string(),
     privileges: z.array(z.object({ privilege: z.string(), grantable: z.boolean() })),
+    is_implicit: z.boolean(),
 });
 const rolePropsSchema = z.object({
     name: z.string(),
@@ -28,6 +30,7 @@ const rolePropsSchema = z.object({
     comment: z.string().nullable(),
     members: z.array(membershipInfoSchema),
     default_privileges: z.array(defaultPrivilegeSchema),
+    security_labels: z.array(securityLabelPropsSchema).default([]).optional(),
 });
 export class Role extends BasePgModel {
     name;
@@ -43,6 +46,7 @@ export class Role extends BasePgModel {
     comment;
     members;
     default_privileges;
+    security_labels;
     constructor(props) {
         super();
         // Identity fields
@@ -58,8 +62,9 @@ export class Role extends BasePgModel {
         this.can_bypass_rls = props.can_bypass_rls;
         this.config = props.config;
         this.comment = props.comment;
-        this.members = props.members;
+        this.members = deduplicateMembers(props.members);
         this.default_privileges = props.default_privileges;
+        this.security_labels = props.security_labels ?? [];
     }
     get stableId() {
         return `role:${this.name}`;
@@ -77,13 +82,16 @@ export class Role extends BasePgModel {
                 Number(a.inherit_option ?? false) - Number(b.inherit_option ?? false) ||
                 Number(a.set_option ?? false) - Number(b.set_option ?? false));
         });
-        const sortedDefaultPrivs = [...this.default_privileges].map((dp) => ({
-            ...dp,
-            privileges: [...dp.privileges].sort((a, b) => {
-                return (a.privilege.localeCompare(b.privilege) ||
-                    Number(a.grantable) - Number(b.grantable));
-            }),
-        }));
+        const sortedDefaultPrivs = [...this.default_privileges].map((dp) => {
+            const { is_implicit: _, ...rest } = dp;
+            return {
+                ...rest,
+                privileges: [...dp.privileges].sort((a, b) => {
+                    return (a.privilege.localeCompare(b.privilege) ||
+                        Number(a.grantable) - Number(b.grantable));
+                }),
+            };
+        });
         sortedDefaultPrivs.sort((a, b) => {
             return ((a.in_schema ?? "").localeCompare(b.in_schema ?? "") ||
                 a.objtype.localeCompare(b.objtype) ||
@@ -102,9 +110,50 @@ export class Role extends BasePgModel {
             comment: this.comment,
             members: sortedMembers,
             default_privileges: sortedDefaultPrivs,
+            security_labels: this.security_labels,
         };
     }
 }
+/**
+ * Deduplicate members by member name.
+ *
+ * In PostgreSQL 16+, `pg_auth_members` can have multiple rows for the same
+ * (roleid, member) pair with different grantors. Merge them into a single
+ * entry per member, combining options with OR so the most permissive wins.
+ *
+ * When merging, prefer a non-self grantor (grantor !== member) so that
+ * downstream code can detect true self-grants (auto-created by CREATE ROLE)
+ * by checking `grantor === member`.
+ */
+function deduplicateMembers(members) {
+    const map = new Map();
+    for (const m of members) {
+        const existing = map.get(m.member);
+        if (existing) {
+            // admin_option is always boolean (non-nullable in schema)
+            existing.admin_option = existing.admin_option || m.admin_option;
+            // inherit_option and set_option are nullish (only available in PG 16+)
+            if (m.inherit_option != null) {
+                existing.inherit_option =
+                    (existing.inherit_option ?? false) || m.inherit_option;
+            }
+            if (m.set_option != null) {
+                existing.set_option = (existing.set_option ?? false) || m.set_option;
+            }
+            // Prefer a non-self grantor so diff can detect true self-grants.
+            // Once a non-self grantor is chosen the value is kept (the specific
+            // non-self grantor doesn't matter — only the self vs non-self
+            // distinction is used downstream).
+            if (existing.grantor === existing.member && m.grantor !== m.member) {
+                existing.grantor = m.grantor;
+            }
+        }
+        else {
+            map.set(m.member, { ...m });
+        }
+    }
+    return [...map.values()];
+}
 export async function extractRoles(pool) {
     // Check PostgreSQL version capabilities for membership options
     const { rows: capabilitiesRows } = await pool.query(sql `
@@ -156,6 +205,18 @@ export async function extractRoles(pool) {
             r.rolbypassrls  AS can_bypass_rls,
             r.rolconfig     AS config,
             obj_description(r.oid, 'pg_authid') AS comment,
+            COALESCE(
+              (
+                SELECT json_agg(
+                  json_build_object('provider', sl.provider, 'label', sl.label)
+                  ORDER BY sl.provider
+                )
+                FROM pg_catalog.pg_shseclabel sl
+                WHERE sl.objoid = r.oid
+                  AND sl.classoid = 'pg_authid'::regclass
+              ),
+              '[]'::json
+            ) AS security_labels,
             COALESCE(rm.members, '[]') AS members,
             COALESCE(
               (
@@ -172,13 +233,15 @@ export async function extractRoles(pool) {
                                     THEN 'PUBLIC'
                                     ELSE s.grantee::regrole::text
                             END,
-                          'privileges', s.privileges
+                          'privileges', s.privileges,
+                          'is_implicit', s.is_implicit
                         )
                         ORDER BY s.defaclnamespace NULLS FIRST,
                                   s.defaclobjtype,
                                   s.grantee
                       )
                 FROM (
+                  -- Explicit entries from pg_default_acl
                   SELECT
                     d.defaclnamespace,
                     d.defaclobjtype,
@@ -189,12 +252,41 @@ export async function extractRoles(pool) {
                         'grantable',  x.is_grantable
                       )
                       ORDER BY x.privilege_type, x.is_grantable
-                    ) AS privileges
+                    ) AS privileges,
+                    false AS is_implicit
                   FROM pg_default_acl d
                   CROSS JOIN LATERAL aclexplode(COALESCE(d.defaclacl, ARRAY[]::aclitem[]))
                     AS x(grantor, grantee, privilege_type, is_grantable)
                   WHERE d.defaclrole = r.oid
                   GROUP BY d.defaclnamespace, d.defaclobjtype, x.grantee
+                  UNION ALL
+                  -- Implicit defaults from acldefault() for objtypes without a
+                  -- global pg_default_acl entry.  PostgreSQL applies these implicit
+                  -- defaults (e.g. PUBLIC gets EXECUTE on functions) when no
+                  -- explicit ALTER DEFAULT PRIVILEGES has been issued.  Including
+                  -- them lets the diff detect REVOKEs of implicit grants.
+                  SELECT
+                    0 AS defaclnamespace,
+                    v.t::"char" AS defaclobjtype,
+                    x.grantee,
+                    json_agg(
+                      json_build_object(
+                        'privilege',  x.privilege_type,
+                        'grantable',  x.is_grantable
+                      )
+                      ORDER BY x.privilege_type, x.is_grantable
+                    ) AS privileges,
+                    true AS is_implicit
+                  FROM (VALUES ('r'), ('S'), ('f'), ('T'), ('n')) AS v(t)
+                  CROSS JOIN LATERAL aclexplode(acldefault(v.t::"char", r.oid))
+                    AS x(grantor, grantee, privilege_type, is_grantable)
+                  WHERE NOT EXISTS (
+                    SELECT 1 FROM pg_default_acl d2
+                    WHERE d2.defaclrole     = r.oid
+                      AND d2.defaclobjtype  = v.t::"char"
+                      AND d2.defaclnamespace = 0
+                  )
+                  GROUP BY v.t, x.grantee
                 ) AS s
               ),
               '[]'
@@ -247,6 +339,18 @@ export async function extractRoles(pool) {
             r.rolbypassrls   AS can_bypass_rls,
             r.rolconfig      AS config,
             obj_description(r.oid, 'pg_authid') AS comment,
+            COALESCE(
+              (
+                SELECT json_agg(
+                  json_build_object('provider', sl.provider, 'label', sl.label)
+                  ORDER BY sl.provider
+                )
+                FROM pg_catalog.pg_shseclabel sl
+                WHERE sl.objoid = r.oid
+                  AND sl.classoid = 'pg_authid'::regclass
+              ),
+              '[]'::json
+            ) AS security_labels,
             COALESCE(rm.members, '[]') AS members,
             COALESCE(
               (
@@ -263,13 +367,15 @@ export async function extractRoles(pool) {
                                     THEN 'PUBLIC'
                                     ELSE s.grantee::regrole::text
                             END,
-                          'privileges', s.privileges
+                          'privileges', s.privileges,
+                          'is_implicit', s.is_implicit
                         )
                         ORDER BY s.defaclnamespace NULLS FIRST,
                                   s.defaclobjtype,
                                   s.grantee
                       )
                 FROM (
+                  -- Explicit entries from pg_default_acl
                   SELECT
                     d.defaclnamespace,
                     d.defaclobjtype,
@@ -280,12 +386,41 @@ export async function extractRoles(pool) {
                         'grantable',  x.is_grantable
                       )
                       ORDER BY x.privilege_type, x.is_grantable
-                    ) AS privileges
+                    ) AS privileges,
+                    false AS is_implicit
                   FROM pg_default_acl d
                   CROSS JOIN LATERAL aclexplode(COALESCE(d.defaclacl, ARRAY[]::aclitem[]))
                     AS x(grantor, grantee, privilege_type, is_grantable)
                   WHERE d.defaclrole = r.oid
                   GROUP BY d.defaclnamespace, d.defaclobjtype, x.grantee
+                  UNION ALL
+                  -- Implicit defaults from acldefault() for objtypes without a
+                  -- global pg_default_acl entry.  PostgreSQL applies these implicit
+                  -- defaults (e.g. PUBLIC gets EXECUTE on functions) when no
+                  -- explicit ALTER DEFAULT PRIVILEGES has been issued.  Including
+                  -- them lets the diff detect REVOKEs of implicit grants.
+                  SELECT
+                    0 AS defaclnamespace,
+                    v.t::"char" AS defaclobjtype,
+                    x.grantee,
+                    json_agg(
+                      json_build_object(
+                        'privilege',  x.privilege_type,
+                        'grantable',  x.is_grantable
+                      )
+                      ORDER BY x.privilege_type, x.is_grantable
+                    ) AS privileges,
+                    true AS is_implicit
+                  FROM (VALUES ('r'), ('S'), ('f'), ('T'), ('n')) AS v(t)
+                  CROSS JOIN LATERAL aclexplode(acldefault(v.t::"char", r.oid))
+                    AS x(grantor, grantee, privilege_type, is_grantable)
+                  WHERE NOT EXISTS (
+                    SELECT 1 FROM pg_default_acl d2
+                    WHERE d2.defaclrole     = r.oid
+                      AND d2.defaclobjtype  = v.t::"char"
+                      AND d2.defaclnamespace = 0
+                  )
+                  GROUP BY v.t, x.grantee
                 ) AS s
               ),
               '[]'

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Rule, RuleEnabledState } from "../rule.model.ts";
 import { AlterRuleChange } from "./rule.base.ts";
 export declare class ReplaceRule extends AlterRuleChange {
@@ -7,7 +8,7 @@ export declare class ReplaceRule extends AlterRuleChange {
         rule: Rule;
     });
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class SetRuleEnabledState extends AlterRuleChange {
     readonly rule: Rule;
@@ -18,5 +19,5 @@ export declare class SetRuleEnabledState extends AlterRuleChange {
         enabled?: RuleEnabledState;
     });
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -15,7 +15,7 @@ export class ReplaceRule extends AlterRuleChange {
             ...this.rule.columns.map((column) => stableId.column(this.rule.schema, this.rule.table_name, column)),
         ];
     }
-    serialize() {
+    serialize(_options) {
         return new CreateRule({ rule: this.rule, orReplace: true }).serialize();
     }
 }
@@ -35,7 +35,7 @@ export class SetRuleEnabledState extends AlterRuleChange {
             ...this.rule.columns.map((column) => stableId.column(this.rule.schema, this.rule.table_name, column)),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const clause = clauseForState(this.enabled);
         return `ALTER TABLE ${this.rule.schema}.${this.rule.table_name} ${clause} ${this.rule.name}`;
     }

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Rule } from "../rule.model.ts";
 import { CreateRuleChange, DropRuleChange } from "./rule.base.ts";
 export declare class CreateCommentOnRule extends CreateRuleChange {
@@ -8,7 +9,7 @@ export declare class CreateCommentOnRule extends CreateRuleChange {
     });
     get creates(): `comment:${string}`[];
     get requires(): `rule:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class DropCommentOnRule extends DropRuleChange {
     readonly rule: Rule;
@@ -18,5 +19,5 @@ export declare class DropCommentOnRule extends DropRuleChange {
     });
     get drops(): `comment:${string}`[];
     get requires(): (`comment:${string}` | `rule:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -14,7 +14,7 @@ export class CreateCommentOnRule extends CreateRuleChange {
     get requires() {
         return [this.rule.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON RULE",
             this.rule.name,
@@ -39,7 +39,7 @@ export class DropCommentOnRule extends DropRuleChange {
     get requires() {
         return [stableId.comment(this.rule.stableId), this.rule.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON RULE",
             this.rule.name,

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Rule } from "../rule.model.ts";
 import { CreateRuleChange } from "./rule.base.ts";
 export declare class CreateRule extends CreateRuleChange {
@@ -10,5 +11,5 @@ export declare class CreateRule extends CreateRuleChange {
     });
     get creates(): `rule:${string}`[];
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -18,7 +18,7 @@ export class CreateRule extends CreateRuleChange {
             ...this.rule.columns.map((column) => stableId.column(this.rule.schema, this.rule.table_name, column)),
         ];
     }
-    serialize() {
+    serialize(_options) {
         let definition = this.rule.definition.trim();
         definition = definition.replace(/^CREATE\s+(?:OR\s+REPLACE\s+)?/i, `CREATE ${this.orReplace ? "OR REPLACE " : ""}`);
         // Remove trailing semicolons (pg_get_ruledef includes them, but we add our own)

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Rule } from "../rule.model.ts";
 import { DropRuleChange } from "./rule.base.ts";
 export declare class DropRule extends DropRuleChange {
@@ -8,5 +9,5 @@ export declare class DropRule extends DropRuleChange {
     });
     get drops(): `rule:${string}`[];
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -12,7 +12,7 @@ export class DropRule extends DropRuleChange {
     get requires() {
         return [this.rule.stableId, this.rule.relationStableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "DROP RULE",
             this.rule.name,

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

@@ -2,4 +2,5 @@ import type { ReplaceRule, SetRuleEnabledState } from "./rule.alter.ts";
 import type { CreateCommentOnRule, DropCommentOnRule } from "./rule.comment.ts";
 import type { CreateRule } from "./rule.create.ts";
 import type { DropRule } from "./rule.drop.ts";
+/** Union of all rule-related change variants (`objectType: "rule"`). @category Change Types */
 export type RuleChange = CreateRule | DropRule | ReplaceRule | SetRuleEnabledState | CreateCommentOnRule | DropCommentOnRule;

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

@@ -1,6 +1,7 @@
 import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../base.model.ts";
+import { type ExtractRetryOptions } from "../extract-with-retry.ts";
 declare const RuleEnabledStateSchema: z.ZodEnum<{
     O: "O";
     D: "D";
@@ -13,10 +14,10 @@ declare const rulePropsSchema: z.ZodObject<{
     table_name: z.ZodString;
     relation_kind: z.ZodEnum<{
         r: "r";
-        f: "f";
         v: "v";
         m: "m";
         p: "p";
+        f: "f";
     }>;
     event: z.ZodEnum<{
         DELETE: "DELETE";
@@ -68,5 +69,5 @@ export declare class Rule extends BasePgModel {
     };
     get relationStableId(): string;
 }
-export declare function extractRules(pool: Pool): Promise<Rule[]>;
+export declare function extractRules(pool: Pool, options?: ExtractRetryOptions): Promise<Rule[]>;
 export {};

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

@@ -1,6 +1,7 @@
 import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../base.model.js";
+import { extractWithDefinitionRetry, } from "../extract-with-retry.js";
 import { stableId } from "../utils.js";
 const RuleEventSchema = z.enum(["SELECT", "INSERT", "UPDATE", "DELETE"]);
 const RuleEnabledStateSchema = z.enum(["O", "D", "R", "A"]);
@@ -24,6 +25,14 @@ const rulePropsSchema = z.object({
     comment: z.string().nullable(),
     columns: z.array(z.string()),
 });
+// pg_get_ruledef(oid, pretty) can return NULL when the rule (its pg_rewrite
+// row) is dropped between catalog scan and resolution, or under transient
+// catalog state. An unreadable rule cannot be diffed, so we accept NULL here
+// and filter the row out at extraction time rather than crashing the whole
+// catalog parse with a ZodError.
+const ruleRowSchema = rulePropsSchema.extend({
+    definition: z.string().nullable(),
+});
 export class Rule extends BasePgModel {
     schema;
     name;
@@ -82,8 +91,13 @@ export class Rule extends BasePgModel {
         }
     }
 }
-export async function extractRules(pool) {
-    const { rows: ruleRows } = await pool.query(sql `
+export async function extractRules(pool, options) {
+    const ruleRows = await extractWithDefinitionRetry({
+        label: "rules",
+        options,
+        hasNullDefinition: (row) => row.definition === null,
+        query: async () => {
+            const result = await pool.query(sql `
       WITH extension_rule_oids AS (
         SELECT
           objid
@@ -149,6 +163,9 @@ export async function extractRules(pool) {
       ORDER BY
         1, 3, 2
   `);
-    const validatedRows = ruleRows.map((row) => rulePropsSchema.parse(row));
+            return result.rows.map((row) => ruleRowSchema.parse(row));
+        },
+    });
+    const validatedRows = ruleRows.filter((row) => row.definition !== null);
     return validatedRows.map((row) => new Rule(row));
 }

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Schema } from "../schema.model.ts";
 import { AlterSchemaChange } from "./schema.base.ts";
 /**
@@ -24,7 +25,7 @@ export declare class AlterSchemaChangeOwner extends AlterSchemaChange {
         owner: string;
     });
     get requires(): `schema:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Replace a schema by dropping and recreating it.

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

@@ -14,7 +14,7 @@ export class AlterSchemaChangeOwner extends AlterSchemaChange {
     get requires() {
         return [this.schema.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return ["ALTER SCHEMA", this.schema.name, "OWNER TO", this.owner].join(" ");
     }
 }

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

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

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Schema } from "../schema.model.ts";
 import { CreateSchemaChange, DropSchemaChange } from "./schema.base.ts";
 export type CommentSchema = CreateCommentOnSchema | DropCommentOnSchema;
@@ -9,7 +10,7 @@ export declare class CreateCommentOnSchema extends CreateSchemaChange {
     });
     get creates(): `comment:${string}`[];
     get requires(): `schema:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class DropCommentOnSchema extends DropSchemaChange {
     readonly schema: Schema;
@@ -19,5 +20,5 @@ export declare class DropCommentOnSchema extends DropSchemaChange {
     });
     get drops(): `comment:${string}`[];
     get requires(): (`schema:${string}` | `comment:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -14,7 +14,7 @@ export class CreateCommentOnSchema extends CreateSchemaChange {
     get requires() {
         return [this.schema.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON SCHEMA",
             this.schema.name,
@@ -37,7 +37,7 @@ export class DropCommentOnSchema extends DropSchemaChange {
     get requires() {
         return [stableId.comment(this.schema.stableId), this.schema.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return ["COMMENT ON SCHEMA", this.schema.name, "IS NULL"].join(" ");
     }
 }

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

@@ -1,3 +1,4 @@
+import type { SchemaSerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Schema } from "../schema.model.ts";
 import { CreateSchemaChange } from "./schema.base.ts";
 /**
@@ -17,11 +18,8 @@ export declare class CreateSchema extends CreateSchemaChange {
     readonly scope: "object";
     constructor(props: {
         schema: Schema;
-        skipAuthorization?: boolean;
-    });
+    } & SchemaSerializeOptions);
     get creates(): `schema:${string}`[];
     get requires(): `role:${string}`[];
-    serialize(options?: {
-        skipAuthorization?: boolean;
-    }): string;
+    serialize(options?: SchemaSerializeOptions): string;
 }

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Schema } from "../schema.model.ts";
 import { DropSchemaChange } from "./schema.base.ts";
 /**
@@ -18,5 +19,5 @@ export declare class DropSchema extends DropSchemaChange {
     });
     get drops(): `schema:${string}`[];
     get requires(): `schema:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -22,7 +22,7 @@ export class DropSchema extends DropSchemaChange {
     get requires() {
         return [this.schema.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return ["DROP SCHEMA", this.schema.name].join(" ");
     }
 }

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Schema } from "../schema.model.ts";
 import { AlterSchemaChange } from "./schema.base.ts";
 export type SchemaPrivilege = GrantSchemaPrivileges | RevokeSchemaPrivileges | RevokeGrantOptionSchemaPrivileges;
@@ -34,7 +35,7 @@ export declare class GrantSchemaPrivileges extends AlterSchemaChange {
     });
     get creates(): `acl:${string}::grantee:${string}`[];
     get requires(): (`schema:${string}` | `role:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke privileges on a schema.
@@ -71,7 +72,7 @@ export declare class RevokeSchemaPrivileges extends AlterSchemaChange {
     });
     get drops(): `acl:${string}::grantee:${string}`[];
     get requires(): (`schema:${string}` | `acl:${string}::grantee:${string}` | `role:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke grant option for privileges on a schema.
@@ -93,5 +94,5 @@ export declare class RevokeGrantOptionSchemaPrivileges extends AlterSchemaChange
         version?: number;
     });
     get requires(): (`schema:${string}` | `acl:${string}::grantee:${string}` | `role:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -33,7 +33,7 @@ export class GrantSchemaPrivileges extends AlterSchemaChange {
     get requires() {
         return [this.schema.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) {
@@ -87,7 +87,7 @@ export class RevokeSchemaPrivileges extends AlterSchemaChange {
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("SCHEMA");
         const list = this.privileges.map((p) => p.privilege);
         const privSql = formatObjectPrivilegeList("SCHEMA", list, this.version);
@@ -122,7 +122,7 @@ export class RevokeGrantOptionSchemaPrivileges extends AlterSchemaChange {
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("SCHEMA");
         const privSql = formatObjectPrivilegeList("SCHEMA", this.privilegeNames, this.version);
         const schemaName = this.schema.name;