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

package/dist/core/objects/materialized-view/materialized-view.model.js

@@ -0,0 +1,228 @@
+import z from "zod";
+import { BasePgModel, columnPropsSchema, } from "../base.model.js";
+import { privilegePropsSchema, } from "../base.privilege-diff.js";
+import { ReplicaIdentitySchema } from "../table/table.model.js";
+const materializedViewPropsSchema = z.object({
+    schema: z.string(),
+    name: z.string(),
+    definition: z.string(),
+    row_security: z.boolean(),
+    force_row_security: z.boolean(),
+    has_indexes: z.boolean(),
+    has_rules: z.boolean(),
+    has_triggers: z.boolean(),
+    has_subclasses: z.boolean(),
+    is_populated: z.boolean(),
+    replica_identity: ReplicaIdentitySchema,
+    is_partition: z.boolean(),
+    options: z.array(z.string()).nullable(),
+    partition_bound: z.string().nullable(),
+    owner: z.string(),
+    comment: z.string().nullable(),
+    columns: z.array(columnPropsSchema),
+    privileges: z.array(privilegePropsSchema),
+});
+export class MaterializedView extends BasePgModel {
+    schema;
+    name;
+    definition;
+    row_security;
+    force_row_security;
+    has_indexes;
+    has_rules;
+    has_triggers;
+    has_subclasses;
+    is_populated;
+    replica_identity;
+    is_partition;
+    options;
+    partition_bound;
+    owner;
+    comment;
+    columns;
+    privileges;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.schema = props.schema;
+        this.name = props.name;
+        // Data fields
+        this.definition = props.definition;
+        this.row_security = props.row_security;
+        this.force_row_security = props.force_row_security;
+        this.has_indexes = props.has_indexes;
+        this.has_rules = props.has_rules;
+        this.has_triggers = props.has_triggers;
+        this.has_subclasses = props.has_subclasses;
+        this.is_populated = props.is_populated;
+        this.replica_identity = props.replica_identity;
+        this.is_partition = props.is_partition;
+        this.options = props.options;
+        this.partition_bound = props.partition_bound;
+        this.owner = props.owner;
+        this.comment = props.comment;
+        this.columns = props.columns;
+        this.privileges = props.privileges;
+    }
+    get stableId() {
+        return `materializedView:${this.schema}.${this.name}`;
+    }
+    get identityFields() {
+        return {
+            schema: this.schema,
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            definition: this.definition,
+            row_security: this.row_security,
+            force_row_security: this.force_row_security,
+            has_indexes: this.has_indexes,
+            has_rules: this.has_rules,
+            has_triggers: this.has_triggers,
+            has_subclasses: this.has_subclasses,
+            is_populated: this.is_populated,
+            replica_identity: this.replica_identity,
+            is_partition: this.is_partition,
+            options: this.options,
+            partition_bound: this.partition_bound,
+            owner: this.owner,
+            comment: this.comment,
+            columns: this.columns,
+            privileges: this.privileges,
+        };
+    }
+    stableSnapshot() {
+        const normalizeColumns = () => [...this.columns]
+            .map((col) => {
+            const { position: _pos, ...rest } = col;
+            return rest;
+        })
+            .sort((a, b) => {
+            const nameA = a.name ?? "";
+            const nameB = b.name ?? "";
+            return nameA.localeCompare(nameB);
+        });
+        return {
+            identity: this.identityFields,
+            data: {
+                ...this.dataFields,
+                columns: normalizeColumns(),
+            },
+        };
+    }
+}
+export async function extractMaterializedViews(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const mvRows = await sql `
+with extension_oids as (
+  select
+    objid
+  from
+    pg_depend d
+  where
+    d.refclassid = 'pg_extension'::regclass
+    and d.classid = 'pg_class'::regclass
+)
+select
+  c.relnamespace::regnamespace::text as schema,
+  quote_ident(c.relname) as name,
+  -- remove trailing semicolon from the definition if present
+  rtrim(pg_get_viewdef(c.oid), ';') as definition,
+  c.relrowsecurity as row_security,
+  c.relforcerowsecurity as force_row_security,
+  c.relhasindex as has_indexes,
+  c.relhasrules as has_rules,
+  c.relhastriggers as has_triggers,
+  c.relhassubclass as has_subclasses,
+  c.relispopulated as is_populated,
+  c.relreplident as replica_identity,
+  c.relispartition as is_partition,
+  c.reloptions as options,
+  pg_get_expr(c.relpartbound, c.oid) as partition_bound,
+  c.relowner::regrole::text as owner,
+  obj_description(c.oid, 'pg_class') as comment,
+  coalesce(json_agg(
+    case when a.attname is not null then
+      json_build_object(
+        'name', quote_ident(a.attname),
+        'position', a.attnum,
+        'data_type', a.atttypid::regtype::text,
+        'data_type_str', format_type(a.atttypid, a.atttypmod),
+        'is_custom_type', ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema'),
+        'custom_type_type', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then ty.typtype else null end,
+        'custom_type_category', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then ty.typcategory else null end,
+        'custom_type_schema', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then ty.typnamespace::regnamespace else null end,
+        'custom_type_name', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then quote_ident(ty.typname) else null end,
+        'not_null', a.attnotnull,
+        'is_identity', a.attidentity != '',
+        'is_identity_always', a.attidentity = 'a',
+        'is_generated', a.attgenerated != '',
+        'collation', (
+          select quote_ident(c2.collname)
+          from pg_collation c2, pg_type t2
+          where c2.oid = a.attcollation
+            and t2.oid = a.atttypid
+            and a.attcollation <> t2.typcollation
+        ),
+        'default', pg_get_expr(ad.adbin, ad.adrelid),
+        'comment', col_description(a.attrelid, a.attnum)
+      )
+    end
+    order by a.attnum
+  ) filter (where a.attname is not null), '[]') as columns,
+  coalesce((
+    select json_agg(
+            json_build_object(
+              'grantee', case when grp.grantee = 0 then 'PUBLIC' else grp.grantee::regrole::text end,
+              'privilege', grp.privilege_type,
+              'grantable', grp.is_grantable,
+              'columns', case when grp.cols is not null and array_length(grp.cols,1) > 0
+                              then grp.cols
+                              else null end
+            )
+            order by grp.grantee, grp.privilege_type
+          )
+    from (
+      select
+        x.grantee,
+        x.privilege_type,
+        bool_or(x.is_grantable) as is_grantable,
+        array_agg(quote_ident(src.attname) order by src.attname)
+          filter (where src.attname is not null) as cols
+      from (
+        -- one row for object ACL + one row per column ACL
+        select null::name as attname, c.relacl as acl
+        union all
+        select a2.attname, a2.attacl
+        from pg_attribute a2
+        where a2.attrelid = c.oid
+          and a2.attnum > 0
+          and not a2.attisdropped
+          and a2.attacl is not null
+      ) as src
+      join lateral aclexplode(src.acl) as x(grantor, grantee, privilege_type, is_grantable) on true
+      group by x.grantee, x.privilege_type
+    ) as grp
+  ), '[]') as privileges
+from
+  pg_catalog.pg_class c
+  left outer join extension_oids e on c.oid = e.objid
+  left join pg_attribute a on a.attrelid = c.oid and a.attnum > 0 and not a.attisdropped
+  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
+where not c.relnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+  and e.objid is null
+  and c.relkind = 'm'
+group by
+  c.oid, c.relnamespace, c.relname, pg_get_viewdef(c.oid), c.relrowsecurity, c.relforcerowsecurity, c.relhasindex, c.relhasrules, c.relhastriggers, c.relhassubclass, c.relispopulated, c.relreplident, c.relispartition, c.reloptions, pg_get_expr(c.relpartbound, c.oid), c.relowner
+order by
+  c.relnamespace::regnamespace, c.relname;
+    `;
+        // Validate and parse each row using the Zod schema
+        const validatedRows = mvRows.map((row) => materializedViewPropsSchema.parse(row));
+        return validatedRows.map((row) => new MaterializedView(row));
+    });
+}

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

@@ -0,0 +1,143 @@
+import type { Procedure } from "../procedure.model.ts";
+import { AlterProcedureChange } from "./procedure.base.ts";
+/**
+ * Alter a procedure.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterfunction.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER FUNCTION name ( [ [ argmode ] [ argname ] argtype [, ...] ] )
+ *     action [, ... ] [ RESTRICT ]
+ * ALTER PROCEDURE name ( [ [ argmode ] [ argname ] argtype [, ...] ] )
+ *     action [, ... ] [ RESTRICT ]
+ * where action is one of:
+ *     [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
+ *     SET configuration_parameter { TO | = } { value | DEFAULT }
+ *     SET configuration_parameter FROM CURRENT
+ *     RESET configuration_parameter
+ *     RESET ALL
+ *     [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
+ *     SET configuration_parameter { TO | = } { value | DEFAULT }
+ *     SET configuration_parameter FROM CURRENT
+ *     RESET configuration_parameter
+ *     RESET ALL
+ * ```
+ */
+export type AlterProcedure = AlterProcedureChangeOwner | AlterProcedureSetConfig | AlterProcedureSetLeakproof | AlterProcedureSetParallel | AlterProcedureSetSecurity | AlterProcedureSetStrictness | AlterProcedureSetVolatility;
+/**
+ * ALTER FUNCTION/PROCEDURE ... OWNER TO ...
+ */
+export declare class AlterProcedureChangeOwner extends AlterProcedureChange {
+    readonly procedure: Procedure;
+    readonly owner: string;
+    readonly scope: "object";
+    constructor(props: {
+        procedure: Procedure;
+        owner: string;
+    });
+    get requires(): `procedure:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER FUNCTION/PROCEDURE ... SECURITY { INVOKER | DEFINER }
+ */
+export declare class AlterProcedureSetSecurity extends AlterProcedureChange {
+    readonly procedure: Procedure;
+    readonly securityDefiner: boolean;
+    readonly scope: "object";
+    constructor(props: {
+        procedure: Procedure;
+        securityDefiner: boolean;
+    });
+    get requires(): `procedure:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER FUNCTION/PROCEDURE ... SET/RESET configuration_parameter
+ * Emits individual RESET for removed keys and SET for added/changed keys.
+ */
+export declare class AlterProcedureSetConfig extends AlterProcedureChange {
+    readonly procedure: Procedure;
+    readonly action: "set" | "reset" | "reset_all";
+    readonly key?: string;
+    readonly value?: string;
+    readonly scope: "object";
+    constructor(props: {
+        procedure: Procedure;
+        action: "set";
+        key: string;
+        value: string;
+    });
+    constructor(props: {
+        procedure: Procedure;
+        action: "reset";
+        key: string;
+    });
+    constructor(props: {
+        procedure: Procedure;
+        action: "reset_all";
+    });
+    get requires(): `procedure:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER FUNCTION/PROCEDURE ... { IMMUTABLE | STABLE | VOLATILE }
+ */
+export declare class AlterProcedureSetVolatility extends AlterProcedureChange {
+    readonly procedure: Procedure;
+    readonly volatility: string;
+    readonly scope: "object";
+    constructor(props: {
+        procedure: Procedure;
+        volatility: string;
+    });
+    get requires(): `procedure:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER FUNCTION/PROCEDURE ... { STRICT | CALLED ON NULL INPUT }
+ */
+export declare class AlterProcedureSetStrictness extends AlterProcedureChange {
+    readonly procedure: Procedure;
+    readonly isStrict: boolean;
+    readonly scope: "object";
+    constructor(props: {
+        procedure: Procedure;
+        isStrict: boolean;
+    });
+    get requires(): `procedure:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER FUNCTION/PROCEDURE ... { LEAKPROOF | NOT LEAKPROOF }
+ */
+export declare class AlterProcedureSetLeakproof extends AlterProcedureChange {
+    readonly procedure: Procedure;
+    readonly leakproof: boolean;
+    readonly scope: "object";
+    constructor(props: {
+        procedure: Procedure;
+        leakproof: boolean;
+    });
+    get requires(): `procedure:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER FUNCTION/PROCEDURE ... PARALLEL { UNSAFE | RESTRICTED | SAFE }
+ */
+export declare class AlterProcedureSetParallel extends AlterProcedureChange {
+    readonly procedure: Procedure;
+    readonly parallelSafety: string;
+    readonly scope: "object";
+    constructor(props: {
+        procedure: Procedure;
+        parallelSafety: string;
+    });
+    get requires(): `procedure:${string}`[];
+    serialize(): string;
+}
+/**
+ * Replace a procedure by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER FUNCTION/PROCEDURE change.
+ */

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

@@ -0,0 +1,207 @@
+import { formatConfigValue } from "../utils.js";
+import { AlterProcedureChange } from "./procedure.base.js";
+/**
+ * ALTER FUNCTION/PROCEDURE ... OWNER TO ...
+ */
+export class AlterProcedureChangeOwner extends AlterProcedureChange {
+    procedure;
+    owner;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.procedure = props.procedure;
+        this.owner = props.owner;
+    }
+    get requires() {
+        return [this.procedure.stableId];
+    }
+    serialize() {
+        const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+        return [
+            "ALTER",
+            objectType,
+            `${this.procedure.schema}.${this.procedure.name}`,
+            "OWNER TO",
+            this.owner,
+        ].join(" ");
+    }
+}
+/**
+ * ALTER FUNCTION/PROCEDURE ... SECURITY { INVOKER | DEFINER }
+ */
+export class AlterProcedureSetSecurity extends AlterProcedureChange {
+    procedure;
+    securityDefiner;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.procedure = props.procedure;
+        this.securityDefiner = props.securityDefiner;
+    }
+    get requires() {
+        return [this.procedure.stableId];
+    }
+    serialize() {
+        const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+        const security = this.securityDefiner
+            ? "SECURITY DEFINER"
+            : "SECURITY INVOKER"; // INVOKER is default; only emitted when changed via diff
+        return [
+            "ALTER",
+            objectType,
+            `${this.procedure.schema}.${this.procedure.name}`,
+            security,
+        ].join(" ");
+    }
+}
+/**
+ * ALTER FUNCTION/PROCEDURE ... SET/RESET configuration_parameter
+ * Emits individual RESET for removed keys and SET for added/changed keys.
+ */
+export class AlterProcedureSetConfig extends AlterProcedureChange {
+    procedure;
+    action;
+    key;
+    value;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.procedure = props.procedure;
+        this.action = props.action;
+        this.key = props.key;
+        this.value = props.value;
+    }
+    get requires() {
+        return [this.procedure.stableId];
+    }
+    serialize() {
+        const head = [
+            "ALTER",
+            this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION",
+            `${this.procedure.schema}.${this.procedure.name}`,
+        ].join(" ");
+        if (this.action === "reset_all")
+            return `${head} RESET ALL`;
+        if (this.action === "reset")
+            return `${head} RESET ${this.key}`;
+        const formatted = formatConfigValue(this.key, this.value);
+        return `${head} SET ${this.key} TO ${formatted}`;
+    }
+}
+/**
+ * ALTER FUNCTION/PROCEDURE ... { IMMUTABLE | STABLE | VOLATILE }
+ */
+export class AlterProcedureSetVolatility extends AlterProcedureChange {
+    procedure;
+    volatility;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.procedure = props.procedure;
+        this.volatility = props.volatility;
+    }
+    get requires() {
+        return [this.procedure.stableId];
+    }
+    serialize() {
+        const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+        const volMap = {
+            i: "IMMUTABLE",
+            s: "STABLE",
+            v: "VOLATILE",
+        };
+        return [
+            "ALTER",
+            objectType,
+            `${this.procedure.schema}.${this.procedure.name}`,
+            volMap[this.volatility],
+        ].join(" ");
+    }
+}
+/**
+ * ALTER FUNCTION/PROCEDURE ... { STRICT | CALLED ON NULL INPUT }
+ */
+export class AlterProcedureSetStrictness extends AlterProcedureChange {
+    procedure;
+    isStrict;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.procedure = props.procedure;
+        this.isStrict = props.isStrict;
+    }
+    get requires() {
+        return [this.procedure.stableId];
+    }
+    serialize() {
+        const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+        const strictness = this.isStrict ? "STRICT" : "CALLED ON NULL INPUT";
+        return [
+            "ALTER",
+            objectType,
+            `${this.procedure.schema}.${this.procedure.name}`,
+            strictness,
+        ].join(" ");
+    }
+}
+/**
+ * ALTER FUNCTION/PROCEDURE ... { LEAKPROOF | NOT LEAKPROOF }
+ */
+export class AlterProcedureSetLeakproof extends AlterProcedureChange {
+    procedure;
+    leakproof;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.procedure = props.procedure;
+        this.leakproof = props.leakproof;
+    }
+    get requires() {
+        return [this.procedure.stableId];
+    }
+    serialize() {
+        const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+        const leak = this.leakproof ? "LEAKPROOF" : "NOT LEAKPROOF";
+        return [
+            "ALTER",
+            objectType,
+            `${this.procedure.schema}.${this.procedure.name}`,
+            leak,
+        ].join(" ");
+    }
+}
+/**
+ * ALTER FUNCTION/PROCEDURE ... PARALLEL { UNSAFE | RESTRICTED | SAFE }
+ */
+export class AlterProcedureSetParallel extends AlterProcedureChange {
+    procedure;
+    parallelSafety;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.procedure = props.procedure;
+        this.parallelSafety = props.parallelSafety;
+    }
+    get requires() {
+        return [this.procedure.stableId];
+    }
+    serialize() {
+        const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+        const parallelMap = {
+            u: "PARALLEL UNSAFE",
+            s: "PARALLEL SAFE",
+            r: "PARALLEL RESTRICTED",
+        };
+        return [
+            "ALTER",
+            objectType,
+            `${this.procedure.schema}.${this.procedure.name}`,
+            parallelMap[this.parallelSafety],
+        ].join(" ");
+    }
+}
+/**
+ * Replace a procedure by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER FUNCTION/PROCEDURE change.
+ */
+// NOTE: ReplaceProcedure removed. Non-alterable changes are emitted as Drop + Create in procedure.diff.ts.

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

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Procedure } from "../procedure.model.ts";
+declare abstract class BaseProcedureChange extends BaseChange {
+    abstract readonly procedure: Procedure;
+    abstract readonly scope: "object" | "comment" | "privilege";
+    readonly objectType: "procedure";
+}
+export declare abstract class CreateProcedureChange extends BaseProcedureChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterProcedureChange extends BaseProcedureChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropProcedureChange extends BaseProcedureChange {
+    readonly operation: "drop";
+}
+export {};

package/dist/core/objects/procedure/changes/procedure.base.js

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../base.change.js";
+class BaseProcedureChange extends BaseChange {
+    objectType = "procedure";
+}
+export class CreateProcedureChange extends BaseProcedureChange {
+    operation = "create";
+}
+export class AlterProcedureChange extends BaseProcedureChange {
+    operation = "alter";
+}
+export class DropProcedureChange extends BaseProcedureChange {
+    operation = "drop";
+}

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

@@ -0,0 +1,26 @@
+import type { Procedure } from "../procedure.model.ts";
+import { CreateProcedureChange, DropProcedureChange } from "./procedure.base.ts";
+export type CommentProcedure = CreateCommentOnProcedure | DropCommentOnProcedure;
+/**
+ * Create/drop comments on procedures/functions.
+ */
+export declare class CreateCommentOnProcedure extends CreateProcedureChange {
+    readonly procedure: Procedure;
+    readonly scope: "comment";
+    constructor(props: {
+        procedure: Procedure;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `procedure:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnProcedure extends DropProcedureChange {
+    readonly procedure: Procedure;
+    readonly scope: "comment";
+    constructor(props: {
+        procedure: Procedure;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `procedure:${string}`)[];
+    serialize(): string;
+}

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

@@ -0,0 +1,52 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateProcedureChange, DropProcedureChange, } from "./procedure.base.js";
+/**
+ * Create/drop comments on procedures/functions.
+ */
+export class CreateCommentOnProcedure extends CreateProcedureChange {
+    procedure;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.procedure = props.procedure;
+    }
+    get creates() {
+        return [stableId.comment(this.procedure.stableId)];
+    }
+    get requires() {
+        return [this.procedure.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON",
+            this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION",
+            `${this.procedure.schema}.${this.procedure.name}(${(this.procedure.argument_types ?? []).join(",")})`,
+            "IS",
+            // biome-ignore lint/style/noNonNullAssertion: procedure comment is not nullable in this case
+            quoteLiteral(this.procedure.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnProcedure extends DropProcedureChange {
+    procedure;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.procedure = props.procedure;
+    }
+    get drops() {
+        return [stableId.comment(this.procedure.stableId)];
+    }
+    get requires() {
+        return [stableId.comment(this.procedure.stableId), this.procedure.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON",
+            this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION",
+            `${this.procedure.schema}.${this.procedure.name}(${(this.procedure.argument_types ?? []).join(",")})`,
+            "IS NULL",
+        ].join(" ");
+    }
+}