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

package/dist/core/objects/language/language.diff.js

@@ -0,0 +1,117 @@
+import { diffObjects } from "../base.diff.js";
+import { diffPrivileges, filterPublicBuiltInDefaults, groupPrivilegesByGrantable, } from "../base.privilege-diff.js";
+import { hasNonAlterableChanges } from "../utils.js";
+import { AlterLanguageChangeOwner } from "./changes/language.alter.js";
+import { CreateCommentOnLanguage, DropCommentOnLanguage, } from "./changes/language.comment.js";
+import { CreateLanguage } from "./changes/language.create.js";
+import { DropLanguage } from "./changes/language.drop.js";
+import { GrantLanguagePrivileges, RevokeGrantOptionLanguagePrivileges, RevokeLanguagePrivileges, } from "./changes/language.privilege.js";
+/**
+ * Diff two sets of languages from main and branch catalogs.
+ *
+ * @param ctx - Context containing version information.
+ * @param main - The languages in the main catalog.
+ * @param branch - The languages in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffLanguages(ctx, main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const languageId of created) {
+        const lang = branch[languageId];
+        changes.push(new CreateLanguage({ language: lang }));
+        if (lang.comment !== null) {
+            changes.push(new CreateCommentOnLanguage({ language: lang }));
+        }
+    }
+    for (const languageId of dropped) {
+        changes.push(new DropLanguage({ language: main[languageId] }));
+    }
+    for (const languageId of altered) {
+        const mainLanguage = main[languageId];
+        const branchLanguage = branch[languageId];
+        // Check if non-alterable properties have changed
+        // These require dropping and recreating the language
+        const NON_ALTERABLE_FIELDS = [
+            "is_trusted",
+            "is_procedural",
+            "call_handler",
+            "inline_handler",
+            "validator",
+        ];
+        const nonAlterablePropsChanged = hasNonAlterableChanges(mainLanguage, branchLanguage, NON_ALTERABLE_FIELDS);
+        if (nonAlterablePropsChanged) {
+            // Replace the entire language (drop + create)
+            changes.push(new DropLanguage({ language: mainLanguage }), new CreateLanguage({ language: branchLanguage }));
+        }
+        else {
+            // Only alterable properties changed - check each one
+            // OWNER
+            if (mainLanguage.owner !== branchLanguage.owner) {
+                changes.push(new AlterLanguageChangeOwner({
+                    language: mainLanguage,
+                    owner: branchLanguage.owner,
+                }));
+            }
+            // COMMENT
+            if (mainLanguage.comment !== branchLanguage.comment) {
+                if (branchLanguage.comment === null) {
+                    changes.push(new DropCommentOnLanguage({ language: mainLanguage }));
+                }
+                else {
+                    changes.push(new CreateCommentOnLanguage({ language: branchLanguage }));
+                }
+            }
+            // Note: Language renaming would also use ALTER LANGUAGE ... RENAME TO ...
+            // But since our Language model uses 'name' as the identity field,
+            // a name change would be handled as drop + create by diffObjects()
+            // PRIVILEGES
+            // Filter out PUBLIC's built-in default USAGE privilege from main catalog
+            // (PostgreSQL grants it automatically, so we shouldn't compare it)
+            const mainPrivilegesFiltered = filterPublicBuiltInDefaults("language", mainLanguage.privileges);
+            // Filter out PUBLIC's built-in default USAGE privilege from branch catalog
+            const branchPrivilegesFiltered = filterPublicBuiltInDefaults("language", branchLanguage.privileges);
+            // Filter out owner privileges - owner always has ALL privileges implicitly
+            // and shouldn't be compared. Use branch owner as the reference.
+            const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchLanguage.owner, ctx.mainRoles);
+            for (const [grantee, result] of privilegeResults) {
+                // Generate grant changes
+                if (result.grants.length > 0) {
+                    const grantGroups = groupPrivilegesByGrantable(result.grants);
+                    for (const [grantable, list] of grantGroups) {
+                        void grantable;
+                        changes.push(new GrantLanguagePrivileges({
+                            language: branchLanguage,
+                            grantee,
+                            privileges: list,
+                            version: ctx.version,
+                        }));
+                    }
+                }
+                // Generate revoke changes
+                if (result.revokes.length > 0) {
+                    const revokeGroups = groupPrivilegesByGrantable(result.revokes);
+                    for (const [grantable, list] of revokeGroups) {
+                        void grantable;
+                        changes.push(new RevokeLanguagePrivileges({
+                            language: mainLanguage,
+                            grantee,
+                            privileges: list,
+                            version: ctx.version,
+                        }));
+                    }
+                }
+                // Generate revoke grant option changes
+                if (result.revokeGrantOption.length > 0) {
+                    changes.push(new RevokeGrantOptionLanguagePrivileges({
+                        language: mainLanguage,
+                        grantee,
+                        privilegeNames: result.revokeGrantOption,
+                        version: ctx.version,
+                    }));
+                }
+            }
+        }
+    }
+    return changes;
+}

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

@@ -0,0 +1,62 @@
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+import { type PrivilegeProps } from "../base.privilege-diff.ts";
+/**
+ * All properties exposed by CREATE LANGUAGE statement are included in diff output.
+ * https://www.postgresql.org/docs/current/sql-createlanguage.html
+ *
+ * ALTER LANGUAGE statement can only be used to rename the language or change the owner.
+ * https://www.postgresql.org/docs/current/sql-alterlanguage.html
+ *
+ * Other properties require dropping and creating a new language.
+ */
+declare const languagePropsSchema: z.ZodObject<{
+    name: z.ZodString;
+    is_trusted: z.ZodBoolean;
+    is_procedural: z.ZodBoolean;
+    call_handler: z.ZodNullable<z.ZodString>;
+    inline_handler: z.ZodNullable<z.ZodString>;
+    validator: 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 LanguagePrivilegeProps = PrivilegeProps;
+export type LanguageProps = z.infer<typeof languagePropsSchema>;
+export declare class Language extends BasePgModel {
+    readonly name: LanguageProps["name"];
+    readonly is_trusted: LanguageProps["is_trusted"];
+    readonly is_procedural: LanguageProps["is_procedural"];
+    readonly call_handler: LanguageProps["call_handler"];
+    readonly inline_handler: LanguageProps["inline_handler"];
+    readonly validator: LanguageProps["validator"];
+    readonly owner: LanguageProps["owner"];
+    readonly comment: LanguageProps["comment"];
+    readonly privileges: LanguagePrivilegeProps[];
+    constructor(props: LanguageProps);
+    get stableId(): `language:${string}`;
+    get identityFields(): {
+        name: string;
+    };
+    get dataFields(): {
+        is_trusted: boolean;
+        is_procedural: boolean;
+        call_handler: string | null;
+        inline_handler: string | null;
+        validator: string | null;
+        owner: string;
+        comment: string | null;
+        privileges: {
+            grantee: string;
+            privilege: string;
+            grantable: boolean;
+            columns?: string[] | null | undefined;
+        }[];
+    };
+}
+export {};

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

@@ -0,0 +1,128 @@
+import z from "zod";
+import { BasePgModel } from "../base.model.js";
+import { privilegePropsSchema, } from "../base.privilege-diff.js";
+/**
+ * All properties exposed by CREATE LANGUAGE statement are included in diff output.
+ * https://www.postgresql.org/docs/current/sql-createlanguage.html
+ *
+ * ALTER LANGUAGE statement can only be used to rename the language or change the owner.
+ * https://www.postgresql.org/docs/current/sql-alterlanguage.html
+ *
+ * Other properties require dropping and creating a new language.
+ */
+const languagePropsSchema = z.object({
+    name: z.string(),
+    is_trusted: z.boolean(),
+    is_procedural: z.boolean(),
+    call_handler: z.string().nullable(),
+    inline_handler: z.string().nullable(),
+    validator: z.string().nullable(),
+    owner: z.string(),
+    comment: z.string().nullable(),
+    privileges: z.array(privilegePropsSchema),
+});
+export class Language extends BasePgModel {
+    name;
+    is_trusted;
+    is_procedural;
+    call_handler;
+    inline_handler;
+    validator;
+    owner;
+    comment;
+    privileges;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.name = props.name;
+        // Data fields
+        this.is_trusted = props.is_trusted;
+        this.is_procedural = props.is_procedural;
+        this.call_handler = props.call_handler;
+        this.inline_handler = props.inline_handler;
+        this.validator = props.validator;
+        this.owner = props.owner;
+        this.comment = props.comment;
+        this.privileges = props.privileges;
+    }
+    get stableId() {
+        return `language:${this.name}`;
+    }
+    get identityFields() {
+        return {
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        const sortedPrivileges = [...this.privileges].sort((a, b) => {
+            return (a.grantee.localeCompare(b.grantee) ||
+                a.privilege.localeCompare(b.privilege) ||
+                Number(a.grantable) - Number(b.grantable));
+        });
+        return {
+            is_trusted: this.is_trusted,
+            is_procedural: this.is_procedural,
+            call_handler: this.call_handler,
+            inline_handler: this.inline_handler,
+            validator: this.validator,
+            owner: this.owner,
+            comment: this.comment,
+            privileges: sortedPrivileges,
+        };
+    }
+}
+async function _extractLanguages(sql) {
+    const languageRows = await sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        return sql `
+    with extension_oids as (
+      select
+        objid
+      from
+        pg_depend d
+      where
+        d.refclassid = 'pg_extension'::regclass
+        and d.classid = 'pg_language'::regclass
+    )
+    select
+      quote_ident(lan.lanname) as name,
+      lan.lanpltrusted as is_trusted,
+      lan.lanispl as is_procedural,
+      lan.lanplcallfoid::regprocedure::text as call_handler,
+      lan.laninline::regprocedure::text as inline_handler,
+      lan.lanvalidator::regprocedure::text as validator,
+      lan.lanowner::regrole::text as owner,
+      obj_description(lan.oid, 'pg_language') 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(lan.lanacl) as x(grantor, grantee, privilege_type, is_grantable)
+        ), '[]'
+      ) as privileges
+    from
+      pg_catalog.pg_language lan
+      left outer join extension_oids e on lan.oid = e.objid
+      -- <EXCLUDE_INTERNAL and default>
+      where lan.lanname not in ('internal', 'c')
+    order by
+      lan.lanname;
+  `;
+    });
+    // Process rows to handle "-" as null values
+    const processedRows = languageRows.map((row) => ({
+        ...row,
+        call_handler: row.call_handler === "-" ? null : row.call_handler,
+        inline_handler: row.inline_handler === "-" ? null : row.inline_handler,
+        validator: row.validator === "-" ? null : row.validator,
+    }));
+    // Validate and parse each row using the Zod schema
+    const validatedRows = processedRows.map((row) => languagePropsSchema.parse(row));
+    return validatedRows.map((row) => new Language(row));
+}

package/dist/core/objects/materialized-view/changes/materialized-view.alter.d.ts

@@ -0,0 +1,67 @@
+import type { MaterializedView } from "../materialized-view.model.ts";
+import { AlterMaterializedViewChange } from "./materialized-view.base.ts";
+/**
+ * Alter a materialized view.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-altermaterializedview.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER MATERIALIZED VIEW [ IF EXISTS ] name
+ *     action [, ... ]
+ * where action is one of:
+ *     ALTER [ COLUMN ] column_name SET STATISTICS integer
+ *     ALTER [ COLUMN ] column_name SET ( attribute_option = value [, ... ] )
+ *     ALTER [ COLUMN ] column_name RESET ( attribute_option [, ... ] )
+ *     ALTER [ COLUMN ] column_name SET STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN }
+ *     CLUSTER ON index_name
+ *     SET WITHOUT CLUSTER
+ *     SET ( storage_parameter [= value] [, ... ] )
+ *     RESET ( storage_parameter [, ... ] )
+ *     OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ *     RENAME TO new_name
+ *     SET SCHEMA new_schema
+ * ```
+ *
+ * Notes for diff-based generation:
+ * - We currently only emit OWNER TO when owner differs.
+ * - Name/schema changes are treated as identity changes; handled as drop/create by the diff engine.
+ * - Column attribute changes, CLUSTER are not modeled and thus not emitted.
+ * - Changes to definition, options, and other non-alterable properties trigger a replace (drop + create).
+ */
+export type AlterMaterializedView = AlterMaterializedViewChangeOwner | AlterMaterializedViewSetStorageParams;
+/**
+ * ALTER MATERIALIZED VIEW ... OWNER TO ...
+ */
+export declare class AlterMaterializedViewChangeOwner extends AlterMaterializedViewChange {
+    readonly materializedView: MaterializedView;
+    readonly owner: string;
+    readonly scope: "object";
+    constructor(props: {
+        materializedView: MaterializedView;
+        owner: string;
+    });
+    get requires(): `materializedView:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER MATERIALIZED VIEW ... SET/RESET ( storage_parameter ... )
+ * Accepts main and branch, computes differences, and emits RESET then SET statements.
+ */
+export declare class AlterMaterializedViewSetStorageParams extends AlterMaterializedViewChange {
+    readonly materializedView: MaterializedView;
+    readonly paramsToSet: string[];
+    readonly keysToReset: string[];
+    readonly scope: "object";
+    constructor(props: {
+        materializedView: MaterializedView;
+        paramsToSet: string[];
+        keysToReset: string[];
+    });
+    get requires(): `materializedView:${string}`[];
+    serialize(): string;
+}
+/**
+ * Replace a materialized view by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER MATERIALIZED VIEW change.
+ */

package/dist/core/objects/materialized-view/changes/materialized-view.alter.js

@@ -0,0 +1,63 @@
+import { AlterMaterializedViewChange } from "./materialized-view.base.js";
+/**
+ * ALTER MATERIALIZED VIEW ... OWNER TO ...
+ */
+export class AlterMaterializedViewChangeOwner extends AlterMaterializedViewChange {
+    materializedView;
+    owner;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.materializedView = props.materializedView;
+        this.owner = props.owner;
+    }
+    get requires() {
+        return [this.materializedView.stableId];
+    }
+    serialize() {
+        return [
+            "ALTER MATERIALIZED VIEW",
+            `${this.materializedView.schema}.${this.materializedView.name}`,
+            "OWNER TO",
+            this.owner,
+        ].join(" ");
+    }
+}
+/**
+ * ALTER MATERIALIZED VIEW ... SET/RESET ( storage_parameter ... )
+ * Accepts main and branch, computes differences, and emits RESET then SET statements.
+ */
+export class AlterMaterializedViewSetStorageParams extends AlterMaterializedViewChange {
+    materializedView;
+    paramsToSet;
+    keysToReset;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.materializedView = props.materializedView;
+        this.paramsToSet = props.paramsToSet;
+        this.keysToReset = props.keysToReset;
+    }
+    get requires() {
+        return [this.materializedView.stableId];
+    }
+    serialize() {
+        const head = [
+            "ALTER MATERIALIZED VIEW",
+            `${this.materializedView.schema}.${this.materializedView.name}`,
+        ].join(" ");
+        const statements = [];
+        if (this.keysToReset.length > 0) {
+            statements.push(`${head} RESET (${this.keysToReset.join(", ")})`);
+        }
+        if (this.paramsToSet.length > 0) {
+            statements.push(`${head} SET (${this.paramsToSet.join(", ")})`);
+        }
+        return statements.join(";\n");
+    }
+}
+/**
+ * Replace a materialized view by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER MATERIALIZED VIEW change.
+ */
+// NOTE: ReplaceMaterializedView removed. Non-alterable changes are emitted as Drop + Create in materialized-view.diff.ts.

package/dist/core/objects/materialized-view/changes/materialized-view.base.d.ts

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../base.change.ts";
+import type { MaterializedView } from "../materialized-view.model.ts";
+declare abstract class BaseMaterializedViewChange extends BaseChange {
+    abstract readonly materializedView: MaterializedView;
+    abstract readonly scope: "object" | "comment" | "privilege";
+    readonly objectType: "materialized_view";
+}
+export declare abstract class CreateMaterializedViewChange extends BaseMaterializedViewChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterMaterializedViewChange extends BaseMaterializedViewChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropMaterializedViewChange extends BaseMaterializedViewChange {
+    readonly operation: "drop";
+}
+export {};

package/dist/core/objects/materialized-view/changes/materialized-view.base.js

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../base.change.js";
+class BaseMaterializedViewChange extends BaseChange {
+    objectType = "materialized_view";
+}
+export class CreateMaterializedViewChange extends BaseMaterializedViewChange {
+    operation = "create";
+}
+export class AlterMaterializedViewChange extends BaseMaterializedViewChange {
+    operation = "alter";
+}
+export class DropMaterializedViewChange extends BaseMaterializedViewChange {
+    operation = "drop";
+}

package/dist/core/objects/materialized-view/changes/materialized-view.comment.d.ts

@@ -0,0 +1,53 @@
+import type { ColumnProps } from "../../base.model.ts";
+import type { MaterializedView } from "../materialized-view.model.ts";
+import { CreateMaterializedViewChange, DropMaterializedViewChange } from "./materialized-view.base.ts";
+export type CommentMaterializedView = CreateCommentOnMaterializedView | CreateCommentOnMaterializedViewColumn | DropCommentOnMaterializedView | DropCommentOnMaterializedViewColumn;
+/**
+ * Create/drop comments on materialized view columns.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-comment.html
+ */
+export declare class CreateCommentOnMaterializedView extends CreateMaterializedViewChange {
+    readonly materializedView: MaterializedView;
+    readonly scope: "comment";
+    constructor(props: {
+        materializedView: MaterializedView;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `materializedView:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnMaterializedView extends DropMaterializedViewChange {
+    readonly materializedView: MaterializedView;
+    readonly scope: "comment";
+    constructor(props: {
+        materializedView: MaterializedView;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `materializedView:${string}`)[];
+    serialize(): string;
+}
+export declare class CreateCommentOnMaterializedViewColumn extends CreateMaterializedViewChange {
+    readonly materializedView: MaterializedView;
+    readonly column: ColumnProps;
+    readonly scope: "comment";
+    constructor(props: {
+        materializedView: MaterializedView;
+        column: ColumnProps;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `column:${string}.${string}.${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnMaterializedViewColumn extends DropMaterializedViewChange {
+    readonly materializedView: MaterializedView;
+    readonly column: ColumnProps;
+    readonly scope: "comment";
+    constructor(props: {
+        materializedView: MaterializedView;
+        column: ColumnProps;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`column:${string}.${string}.${string}` | `comment:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/materialized-view/changes/materialized-view.comment.js

@@ -0,0 +1,112 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateMaterializedViewChange, DropMaterializedViewChange, } from "./materialized-view.base.js";
+/**
+ * Create/drop comments on materialized view columns.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-comment.html
+ */
+export class CreateCommentOnMaterializedView extends CreateMaterializedViewChange {
+    materializedView;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.materializedView = props.materializedView;
+    }
+    get creates() {
+        return [stableId.comment(this.materializedView.stableId)];
+    }
+    get requires() {
+        return [this.materializedView.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON MATERIALIZED VIEW",
+            `${this.materializedView.schema}.${this.materializedView.name}`,
+            "IS",
+            // biome-ignore lint/style/noNonNullAssertion: mv comment is not nullable in this case
+            quoteLiteral(this.materializedView.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnMaterializedView extends DropMaterializedViewChange {
+    materializedView;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.materializedView = props.materializedView;
+    }
+    get drops() {
+        return [stableId.comment(this.materializedView.stableId)];
+    }
+    get requires() {
+        return [
+            stableId.comment(this.materializedView.stableId),
+            this.materializedView.stableId,
+        ];
+    }
+    serialize() {
+        return [
+            "COMMENT ON MATERIALIZED VIEW",
+            `${this.materializedView.schema}.${this.materializedView.name}`,
+            "IS NULL",
+        ].join(" ");
+    }
+}
+export class CreateCommentOnMaterializedViewColumn extends CreateMaterializedViewChange {
+    materializedView;
+    column;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.materializedView = props.materializedView;
+        this.column = props.column;
+    }
+    get creates() {
+        return [
+            stableId.comment(stableId.column(this.materializedView.schema, this.materializedView.name, this.column.name)),
+        ];
+    }
+    get requires() {
+        return [
+            stableId.column(this.materializedView.schema, this.materializedView.name, this.column.name),
+        ];
+    }
+    serialize() {
+        return [
+            "COMMENT ON COLUMN",
+            `${this.materializedView.schema}.${this.materializedView.name}.${this.column.name}`,
+            "IS",
+            // biome-ignore lint/style/noNonNullAssertion: column comment is not nullable in this case
+            quoteLiteral(this.column.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnMaterializedViewColumn extends DropMaterializedViewChange {
+    materializedView;
+    column;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.materializedView = props.materializedView;
+        this.column = props.column;
+    }
+    get drops() {
+        return [
+            stableId.comment(stableId.column(this.materializedView.schema, this.materializedView.name, this.column.name)),
+        ];
+    }
+    get requires() {
+        return [
+            stableId.comment(stableId.column(this.materializedView.schema, this.materializedView.name, this.column.name)),
+            stableId.column(this.materializedView.schema, this.materializedView.name, this.column.name),
+        ];
+    }
+    serialize() {
+        return [
+            "COMMENT ON COLUMN",
+            `${this.materializedView.schema}.${this.materializedView.name}.${this.column.name}`,
+            "IS NULL",
+        ].join(" ");
+    }
+}

package/dist/core/objects/materialized-view/changes/materialized-view.create.d.ts

@@ -0,0 +1,35 @@
+import type { MaterializedView } from "../materialized-view.model.ts";
+import { CreateMaterializedViewChange } from "./materialized-view.base.ts";
+/**
+ * Create a materialized view.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-creatematerializedview.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE MATERIALIZED VIEW [ IF NOT EXISTS ] table_name
+ *     [ (column_name [, ...] ) ]
+ *     [ WITH ( storage_parameter [= value] [, ... ] ) ]
+ *     [ TABLESPACE tablespace_name ]
+ *     AS query
+ *     [ WITH [ NO ] DATA ]
+ * ```
+ *
+ * Notes for diff-based generation:
+ * - IF NOT EXISTS is omitted: diffs are deterministic and explicit.
+ * - (column_name, ...) list is derived from the SELECT query; we don't emit it.
+ * - TABLESPACE is not currently modeled/extracted and is not emitted.
+ * - WITH (options) is emitted only when non-empty.
+ * - WITH NO DATA is always emitted when is_populated is false to ensure correct state.
+ * - WITH DATA is emitted when is_populated is true.
+ */
+export declare class CreateMaterializedView extends CreateMaterializedViewChange {
+    readonly materializedView: MaterializedView;
+    readonly scope: "object";
+    constructor(props: {
+        materializedView: MaterializedView;
+    });
+    get creates(): (`column:${string}.${string}.${string}` | `materializedView:${string}`)[];
+    get requires(): string[];
+    serialize(): string;
+}