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

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

@@ -0,0 +1,174 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+import { type PrivilegeProps } from "../base.privilege-diff.ts";
+declare const aggregatePropsSchema: z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+    identity_arguments: z.ZodString;
+    kind: z.ZodLiteral<"a">;
+    aggkind: z.ZodEnum<{
+        n: "n";
+        o: "o";
+        h: "h";
+    }>;
+    num_direct_args: z.ZodNumber;
+    return_type: z.ZodString;
+    return_type_schema: z.ZodNullable<z.ZodString>;
+    parallel_safety: z.ZodEnum<{
+        u: "u";
+        s: "s";
+        r: "r";
+    }>;
+    is_strict: z.ZodBoolean;
+    transition_function: z.ZodString;
+    state_data_type: z.ZodString;
+    state_data_type_schema: z.ZodNullable<z.ZodString>;
+    state_data_space: z.ZodNumber;
+    final_function: z.ZodNullable<z.ZodString>;
+    final_function_extra_args: z.ZodBoolean;
+    final_function_modify: z.ZodNullable<z.ZodEnum<{
+        s: "s";
+        r: "r";
+        w: "w";
+    }>>;
+    combine_function: z.ZodNullable<z.ZodString>;
+    serial_function: z.ZodNullable<z.ZodString>;
+    deserial_function: z.ZodNullable<z.ZodString>;
+    initial_condition: z.ZodNullable<z.ZodString>;
+    moving_transition_function: z.ZodNullable<z.ZodString>;
+    moving_inverse_function: z.ZodNullable<z.ZodString>;
+    moving_state_data_type: z.ZodNullable<z.ZodString>;
+    moving_state_data_type_schema: z.ZodNullable<z.ZodString>;
+    moving_state_data_space: z.ZodNullable<z.ZodNumber>;
+    moving_final_function: z.ZodNullable<z.ZodString>;
+    moving_final_function_extra_args: z.ZodBoolean;
+    moving_final_function_modify: z.ZodNullable<z.ZodEnum<{
+        s: "s";
+        r: "r";
+        w: "w";
+    }>>;
+    moving_initial_condition: z.ZodNullable<z.ZodString>;
+    sort_operator: z.ZodNullable<z.ZodString>;
+    argument_count: z.ZodNumber;
+    argument_default_count: z.ZodNumber;
+    argument_names: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    argument_types: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    all_argument_types: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    argument_modes: z.ZodNullable<z.ZodArray<z.ZodEnum<{
+        i: "i";
+        o: "o";
+        b: "b";
+        v: "v";
+        t: "t";
+    }>>>;
+    argument_defaults: z.ZodNullable<z.ZodString>;
+    owner: z.ZodString;
+    comment: z.ZodNullable<z.ZodString>;
+    privileges: z.ZodArray<z.ZodObject<{
+        grantee: z.ZodString;
+        privilege: z.ZodString;
+        grantable: z.ZodBoolean;
+        columns: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.z.core.$strip>>;
+}, z.z.core.$strip>;
+type AggregatePrivilegeProps = PrivilegeProps;
+type AggregateProps = z.infer<typeof aggregatePropsSchema>;
+export declare class Aggregate extends BasePgModel {
+    readonly schema: AggregateProps["schema"];
+    readonly name: AggregateProps["name"];
+    readonly identityArguments: AggregateProps["identity_arguments"];
+    readonly kind: AggregateProps["kind"];
+    readonly aggkind: AggregateProps["aggkind"];
+    readonly num_direct_args: AggregateProps["num_direct_args"];
+    readonly return_type: AggregateProps["return_type"];
+    readonly return_type_schema: AggregateProps["return_type_schema"];
+    readonly parallel_safety: AggregateProps["parallel_safety"];
+    readonly is_strict: AggregateProps["is_strict"];
+    readonly transition_function: AggregateProps["transition_function"];
+    readonly state_data_type: AggregateProps["state_data_type"];
+    readonly state_data_type_schema: AggregateProps["state_data_type_schema"];
+    readonly state_data_space: AggregateProps["state_data_space"];
+    readonly final_function: AggregateProps["final_function"];
+    readonly final_function_extra_args: AggregateProps["final_function_extra_args"];
+    readonly final_function_modify: AggregateProps["final_function_modify"];
+    readonly combine_function: AggregateProps["combine_function"];
+    readonly serial_function: AggregateProps["serial_function"];
+    readonly deserial_function: AggregateProps["deserial_function"];
+    readonly initial_condition: AggregateProps["initial_condition"];
+    readonly moving_transition_function: AggregateProps["moving_transition_function"];
+    readonly moving_inverse_function: AggregateProps["moving_inverse_function"];
+    readonly moving_state_data_type: AggregateProps["moving_state_data_type"];
+    readonly moving_state_data_type_schema: AggregateProps["moving_state_data_type_schema"];
+    readonly moving_state_data_space: AggregateProps["moving_state_data_space"];
+    readonly moving_final_function: AggregateProps["moving_final_function"];
+    readonly moving_final_function_extra_args: AggregateProps["moving_final_function_extra_args"];
+    readonly moving_final_function_modify: AggregateProps["moving_final_function_modify"];
+    readonly moving_initial_condition: AggregateProps["moving_initial_condition"];
+    readonly sort_operator: AggregateProps["sort_operator"];
+    readonly argument_count: AggregateProps["argument_count"];
+    readonly argument_default_count: AggregateProps["argument_default_count"];
+    readonly argument_names: AggregateProps["argument_names"];
+    readonly argument_types: AggregateProps["argument_types"];
+    readonly all_argument_types: AggregateProps["all_argument_types"];
+    readonly argument_modes: AggregateProps["argument_modes"];
+    readonly argument_defaults: AggregateProps["argument_defaults"];
+    readonly owner: AggregateProps["owner"];
+    readonly comment: AggregateProps["comment"];
+    readonly privileges: AggregatePrivilegeProps[];
+    constructor(props: AggregateProps);
+    get stableId(): `aggregate:${string}`;
+    get identityFields(): {
+        schema: string;
+        name: string;
+        identity_arguments: string;
+    };
+    get dataFields(): {
+        kind: "a";
+        aggkind: "n" | "o" | "h";
+        num_direct_args: number;
+        return_type: string;
+        return_type_schema: string | null;
+        parallel_safety: "u" | "s" | "r";
+        is_strict: boolean;
+        transition_function: string;
+        state_data_type: string;
+        state_data_type_schema: string | null;
+        state_data_space: number;
+        final_function: string | null;
+        final_function_extra_args: boolean;
+        final_function_modify: "s" | "r" | "w" | null;
+        combine_function: string | null;
+        serial_function: string | null;
+        deserial_function: string | null;
+        initial_condition: string | null;
+        moving_transition_function: string | null;
+        moving_inverse_function: string | null;
+        moving_state_data_type: string | null;
+        moving_state_data_type_schema: string | null;
+        moving_state_data_space: number | null;
+        moving_final_function: string | null;
+        moving_final_function_extra_args: boolean;
+        moving_final_function_modify: "s" | "r" | "w" | null;
+        moving_initial_condition: string | null;
+        sort_operator: string | null;
+        argument_count: number;
+        argument_default_count: number;
+        argument_names: string[] | null;
+        argument_types: string[] | null;
+        all_argument_types: string[] | null;
+        argument_modes: ("i" | "o" | "b" | "v" | "t")[] | null;
+        argument_defaults: string | null;
+        identity_arguments: string;
+        owner: string;
+        comment: string | null;
+        privileges: {
+            grantee: string;
+            privilege: string;
+            grantable: boolean;
+            columns?: string[] | null | undefined;
+        }[];
+    };
+}
+export declare function extractAggregates(sql: Sql): Promise<Aggregate[]>;
+export {};

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

@@ -0,0 +1,297 @@
+import z from "zod";
+import { BasePgModel } from "../base.model.js";
+import { privilegePropsSchema, } from "../base.privilege-diff.js";
+const AggregateKindSchema = z.enum([
+    "n", // normal aggregate
+    "o", // ordered-set aggregate
+    "h", // hypothetical-set aggregate
+]);
+const FunctionParallelSafetySchema = z.enum([
+    "u", // UNSAFE
+    "s", // SAFE
+    "r", // RESTRICTED
+]);
+const FunctionArgumentModeSchema = z.enum([
+    "i", // IN parameter
+    "o", // OUT parameter
+    "b", // INOUT parameter
+    "v", // VARIADIC parameter
+    "t", // TABLE parameter
+]);
+const FinalFunctionModifySchema = z.enum([
+    "r", // READ_ONLY
+    "s", // SHAREABLE
+    "w", // READ_WRITE
+]);
+const aggregatePropsSchema = z.object({
+    schema: z.string(),
+    name: z.string(),
+    identity_arguments: z.string(),
+    kind: z.literal("a"),
+    aggkind: AggregateKindSchema,
+    num_direct_args: z.number(),
+    return_type: z.string(),
+    return_type_schema: z.string().nullable(),
+    parallel_safety: FunctionParallelSafetySchema,
+    is_strict: z.boolean(),
+    transition_function: z.string(),
+    state_data_type: z.string(),
+    state_data_type_schema: z.string().nullable(),
+    state_data_space: z.number(),
+    final_function: z.string().nullable(),
+    final_function_extra_args: z.boolean(),
+    final_function_modify: FinalFunctionModifySchema.nullable(),
+    combine_function: z.string().nullable(),
+    serial_function: z.string().nullable(),
+    deserial_function: z.string().nullable(),
+    initial_condition: z.string().nullable(),
+    moving_transition_function: z.string().nullable(),
+    moving_inverse_function: z.string().nullable(),
+    moving_state_data_type: z.string().nullable(),
+    moving_state_data_type_schema: z.string().nullable(),
+    moving_state_data_space: z.number().nullable(),
+    moving_final_function: z.string().nullable(),
+    moving_final_function_extra_args: z.boolean(),
+    moving_final_function_modify: FinalFunctionModifySchema.nullable(),
+    moving_initial_condition: z.string().nullable(),
+    sort_operator: z.string().nullable(),
+    argument_count: z.number(),
+    argument_default_count: z.number(),
+    argument_names: z.array(z.string()).nullable(),
+    argument_types: z.array(z.string()).nullable(),
+    all_argument_types: z.array(z.string()).nullable(),
+    argument_modes: z.array(FunctionArgumentModeSchema).nullable(),
+    argument_defaults: z.string().nullable(),
+    owner: z.string(),
+    comment: z.string().nullable(),
+    privileges: z.array(privilegePropsSchema),
+});
+export class Aggregate extends BasePgModel {
+    schema;
+    name;
+    identityArguments;
+    kind;
+    aggkind;
+    num_direct_args;
+    return_type;
+    return_type_schema;
+    parallel_safety;
+    is_strict;
+    transition_function;
+    state_data_type;
+    state_data_type_schema;
+    state_data_space;
+    final_function;
+    final_function_extra_args;
+    final_function_modify;
+    combine_function;
+    serial_function;
+    deserial_function;
+    initial_condition;
+    moving_transition_function;
+    moving_inverse_function;
+    moving_state_data_type;
+    moving_state_data_type_schema;
+    moving_state_data_space;
+    moving_final_function;
+    moving_final_function_extra_args;
+    moving_final_function_modify;
+    moving_initial_condition;
+    sort_operator;
+    argument_count;
+    argument_default_count;
+    argument_names;
+    argument_types;
+    all_argument_types;
+    argument_modes;
+    argument_defaults;
+    owner;
+    comment;
+    privileges;
+    constructor(props) {
+        super();
+        this.schema = props.schema;
+        this.name = props.name;
+        this.identityArguments = props.identity_arguments.trim();
+        this.kind = props.kind;
+        this.aggkind = props.aggkind;
+        this.num_direct_args = props.num_direct_args;
+        this.return_type = props.return_type;
+        this.return_type_schema = props.return_type_schema;
+        this.parallel_safety = props.parallel_safety;
+        this.is_strict = props.is_strict;
+        this.transition_function = props.transition_function;
+        this.state_data_type = props.state_data_type;
+        this.state_data_type_schema = props.state_data_type_schema;
+        this.state_data_space = props.state_data_space;
+        this.final_function = props.final_function;
+        this.final_function_extra_args = props.final_function_extra_args;
+        this.final_function_modify = props.final_function_modify;
+        this.combine_function = props.combine_function;
+        this.serial_function = props.serial_function;
+        this.deserial_function = props.deserial_function;
+        this.initial_condition = props.initial_condition;
+        this.moving_transition_function = props.moving_transition_function;
+        this.moving_inverse_function = props.moving_inverse_function;
+        this.moving_state_data_type = props.moving_state_data_type;
+        this.moving_state_data_type_schema = props.moving_state_data_type_schema;
+        this.moving_state_data_space = props.moving_state_data_space;
+        this.moving_final_function = props.moving_final_function;
+        this.moving_final_function_extra_args =
+            props.moving_final_function_extra_args;
+        this.moving_final_function_modify = props.moving_final_function_modify;
+        this.moving_initial_condition = props.moving_initial_condition;
+        this.sort_operator = props.sort_operator;
+        this.argument_count = props.argument_count;
+        this.argument_default_count = props.argument_default_count;
+        this.argument_names = props.argument_names;
+        this.argument_types = props.argument_types;
+        this.all_argument_types = props.all_argument_types;
+        this.argument_modes = props.argument_modes;
+        this.argument_defaults = props.argument_defaults;
+        this.owner = props.owner;
+        this.comment = props.comment;
+        this.privileges = props.privileges;
+    }
+    get stableId() {
+        const normalized = this.identityArguments;
+        return `aggregate:${this.schema}.${this.name}(${normalized})`;
+    }
+    get identityFields() {
+        return {
+            schema: this.schema,
+            name: this.name,
+            identity_arguments: this.identityArguments,
+        };
+    }
+    get dataFields() {
+        return {
+            kind: this.kind,
+            aggkind: this.aggkind,
+            num_direct_args: this.num_direct_args,
+            return_type: this.return_type,
+            return_type_schema: this.return_type_schema,
+            parallel_safety: this.parallel_safety,
+            is_strict: this.is_strict,
+            transition_function: this.transition_function,
+            state_data_type: this.state_data_type,
+            state_data_type_schema: this.state_data_type_schema,
+            state_data_space: this.state_data_space,
+            final_function: this.final_function,
+            final_function_extra_args: this.final_function_extra_args,
+            final_function_modify: this.final_function_modify,
+            combine_function: this.combine_function,
+            serial_function: this.serial_function,
+            deserial_function: this.deserial_function,
+            initial_condition: this.initial_condition,
+            moving_transition_function: this.moving_transition_function,
+            moving_inverse_function: this.moving_inverse_function,
+            moving_state_data_type: this.moving_state_data_type,
+            moving_state_data_type_schema: this.moving_state_data_type_schema,
+            moving_state_data_space: this.moving_state_data_space,
+            moving_final_function: this.moving_final_function,
+            moving_final_function_extra_args: this.moving_final_function_extra_args,
+            moving_final_function_modify: this.moving_final_function_modify,
+            moving_initial_condition: this.moving_initial_condition,
+            sort_operator: this.sort_operator,
+            argument_count: this.argument_count,
+            argument_default_count: this.argument_default_count,
+            argument_names: this.argument_names,
+            argument_types: this.argument_types,
+            all_argument_types: this.all_argument_types,
+            argument_modes: this.argument_modes,
+            argument_defaults: this.argument_defaults,
+            identity_arguments: this.identityArguments,
+            owner: this.owner,
+            comment: this.comment,
+            privileges: this.privileges,
+        };
+    }
+}
+export async function extractAggregates(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const aggregateRows = await sql `
+with extension_oids as (
+  select
+    objid
+  from
+    pg_depend d
+  where
+    d.refclassid = 'pg_extension'::regclass
+    and d.classid = 'pg_proc'::regclass
+)
+select
+  p.pronamespace::regnamespace::text as schema,
+  quote_ident(p.proname) as name,
+  pg_catalog.pg_get_function_identity_arguments(p.oid) as identity_arguments,
+  p.prokind as kind,
+  a.aggkind,
+  a.aggnumdirectargs as num_direct_args,
+  format_type(p.prorettype, null) as return_type,
+  rt.typnamespace::regnamespace::text as return_type_schema,
+  p.proparallel as parallel_safety,
+  p.proisstrict as is_strict,
+  a.aggtransfn::regprocedure::text as transition_function,
+  format_type(a.aggtranstype, null) as state_data_type,
+  st.typnamespace::regnamespace::text as state_data_type_schema,
+  a.aggtransspace as state_data_space,
+  case when a.aggfinalfn = 0 then null else a.aggfinalfn::regprocedure::text end as final_function,
+  a.aggfinalextra as final_function_extra_args,
+  nullif(a.aggfinalmodify::text, ' ') as final_function_modify,
+  case when a.aggcombinefn = 0 then null else a.aggcombinefn::regprocedure::text end as combine_function,
+  case when a.aggserialfn = 0 then null else a.aggserialfn::regprocedure::text end as serial_function,
+  case when a.aggdeserialfn = 0 then null else a.aggdeserialfn::regprocedure::text end as deserial_function,
+  a.agginitval as initial_condition,
+  case when a.aggmtransfn = 0 then null else a.aggmtransfn::regprocedure::text end as moving_transition_function,
+  case when a.aggminvtransfn = 0 then null else a.aggminvtransfn::regprocedure::text end as moving_inverse_function,
+  case when a.aggmtranstype = 0 then null else format_type(a.aggmtranstype, null) end as moving_state_data_type,
+  case when a.aggmtranstype = 0 then null else mt.typnamespace::regnamespace::text end as moving_state_data_type_schema,
+  case when a.aggmtransfn = 0 then null else a.aggmtransspace end as moving_state_data_space,
+  case when a.aggmfinalfn = 0 then null else a.aggmfinalfn::regprocedure::text end as moving_final_function,
+  a.aggmfinalextra as moving_final_function_extra_args,
+  nullif(a.aggmfinalmodify::text, ' ') as moving_final_function_modify,
+  a.aggminitval as moving_initial_condition,
+  case when a.aggsortop = 0 then null else a.aggsortop::regoperator::text end as sort_operator,
+  p.pronargs as argument_count,
+  p.pronargdefaults as argument_default_count,
+  case when p.proargnames is null then null
+       else array(select quote_ident(n) from unnest(p.proargnames) as n)
+  end as argument_names,
+  array(select format_type(oid, null) from unnest(p.proargtypes) as oid) as argument_types,
+  array(select format_type(oid, null) from unnest(p.proallargtypes) as oid) as all_argument_types,
+  p.proargmodes as argument_modes,
+  pg_get_expr(p.proargdefaults, 0) as argument_defaults,
+  p.proowner::regrole::text as owner,
+  obj_description(p.oid, 'pg_proc') as comment,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object(
+          'grantee', case when x.grantee = 0 then 'PUBLIC' else x.grantee::regrole::text end,
+          'privilege', x.privilege_type,
+          'grantable', x.is_grantable
+        )
+        order by x.grantee, x.privilege_type
+      )
+      from lateral aclexplode(p.proacl) as x(grantor, grantee, privilege_type, is_grantable)
+    ), '[]'
+  ) as privileges
+from
+  pg_catalog.pg_proc p
+  inner join pg_catalog.pg_aggregate a on a.aggfnoid = p.oid
+  left join pg_catalog.pg_type rt on rt.oid = p.prorettype
+  left join pg_catalog.pg_type st on st.oid = a.aggtranstype
+  left join pg_catalog.pg_type mt on mt.oid = a.aggmtranstype
+  left outer join extension_oids e on p.oid = e.objid
+where
+  p.prokind = 'a'
+  and not p.pronamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+  and e.objid is null
+order by
+  1, 2, 3;
+    `;
+        const validatedRows = aggregateRows.map((row) => aggregatePropsSchema.parse(row));
+        return validatedRows.map((row) => new Aggregate(row));
+    });
+}

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

@@ -0,0 +1,19 @@
+import type { Aggregate } from "../aggregate.model.ts";
+import { AlterAggregateChange } from "./aggregate.base.ts";
+export type AlterAggregate = AlterAggregateChangeOwner;
+/**
+ * ALTER AGGREGATE ... OWNER TO ...
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alteraggregate.html
+ */
+export declare class AlterAggregateChangeOwner extends AlterAggregateChange {
+    readonly aggregate: Aggregate;
+    readonly owner: string;
+    readonly scope: "object";
+    constructor(props: {
+        aggregate: Aggregate;
+        owner: string;
+    });
+    get requires(): `aggregate:${string}`[];
+    serialize(): string;
+}

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

@@ -0,0 +1,25 @@
+import { AlterAggregateChange } from "./aggregate.base.js";
+/**
+ * ALTER AGGREGATE ... OWNER TO ...
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alteraggregate.html
+ */
+export class AlterAggregateChangeOwner extends AlterAggregateChange {
+    aggregate;
+    owner;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.aggregate = props.aggregate;
+        this.owner = props.owner;
+    }
+    get requires() {
+        return [this.aggregate.stableId];
+    }
+    serialize() {
+        const signature = this.aggregate.identityArguments;
+        const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
+        const withArgs = signature.length > 0 ? `(${signature})` : "()";
+        return `ALTER AGGREGATE ${qualifiedName}${withArgs} OWNER TO ${this.owner}`;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Aggregate } from "../aggregate.model.ts";
+declare abstract class BaseAggregateChange extends BaseChange {
+    abstract readonly aggregate: Aggregate;
+    abstract readonly scope: "object" | "comment" | "privilege";
+    readonly objectType: "aggregate";
+}
+export declare abstract class CreateAggregateChange extends BaseAggregateChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterAggregateChange extends BaseAggregateChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropAggregateChange extends BaseAggregateChange {
+    readonly operation: "drop";
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../base.change.js";
+class BaseAggregateChange extends BaseChange {
+    objectType = "aggregate";
+}
+export class CreateAggregateChange extends BaseAggregateChange {
+    operation = "create";
+}
+export class AlterAggregateChange extends BaseAggregateChange {
+    operation = "alter";
+}
+export class DropAggregateChange extends BaseAggregateChange {
+    operation = "drop";
+}

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

@@ -0,0 +1,23 @@
+import type { Aggregate } from "../aggregate.model.ts";
+import { CreateAggregateChange, DropAggregateChange } from "./aggregate.base.ts";
+export type CommentAggregate = CreateCommentOnAggregate | DropCommentOnAggregate;
+export declare class CreateCommentOnAggregate extends CreateAggregateChange {
+    readonly aggregate: Aggregate;
+    readonly scope: "comment";
+    constructor(props: {
+        aggregate: Aggregate;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `aggregate:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnAggregate extends DropAggregateChange {
+    readonly aggregate: Aggregate;
+    readonly scope: "comment";
+    constructor(props: {
+        aggregate: Aggregate;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `aggregate:${string}`)[];
+    serialize(): string;
+}

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

@@ -0,0 +1,44 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateAggregateChange, DropAggregateChange, } from "./aggregate.base.js";
+export class CreateCommentOnAggregate extends CreateAggregateChange {
+    aggregate;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.aggregate = props.aggregate;
+    }
+    get creates() {
+        return [stableId.comment(this.aggregate.stableId)];
+    }
+    get requires() {
+        return [this.aggregate.stableId];
+    }
+    serialize() {
+        const signature = this.aggregate.identityArguments;
+        const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
+        const withArgs = signature.length > 0 ? `(${signature})` : "()";
+        // biome-ignore lint/style/noNonNullAssertion: aggregate comment is non-null in this branch
+        return `COMMENT ON AGGREGATE ${qualifiedName}${withArgs} IS ${quoteLiteral(this.aggregate.comment)}`;
+    }
+}
+export class DropCommentOnAggregate extends DropAggregateChange {
+    aggregate;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.aggregate = props.aggregate;
+    }
+    get drops() {
+        return [stableId.comment(this.aggregate.stableId)];
+    }
+    get requires() {
+        return [stableId.comment(this.aggregate.stableId), this.aggregate.stableId];
+    }
+    serialize() {
+        const signature = this.aggregate.identityArguments;
+        const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
+        const withArgs = signature.length > 0 ? `(${signature})` : "()";
+        return `COMMENT ON AGGREGATE ${qualifiedName}${withArgs} IS NULL`;
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { Aggregate } from "../aggregate.model.ts";
+import { CreateAggregateChange } from "./aggregate.base.ts";
+/**
+ * Create an aggregate.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createaggregate.html
+ */
+export declare class CreateAggregate extends CreateAggregateChange {
+    readonly aggregate: Aggregate;
+    readonly orReplace: boolean;
+    readonly scope: "object";
+    constructor(props: {
+        aggregate: Aggregate;
+        orReplace?: boolean;
+    });
+    get creates(): `aggregate:${string}`[];
+    get requires(): string[];
+    serialize(): string;
+}