@supabase/pg-delta 1.0.0-alpha.2 → 1.0.0-alpha.20

package/src/core/objects/language/language.model.ts

@@ -0,0 +1,150 @@
+import { sql } from "@ts-safeql/sql-tag";
+import type { Pool } from "pg";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+import {
+  type PrivilegeProps,
+  privilegePropsSchema,
+} 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.
+ */
+
+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),
+});
+
+type LanguagePrivilegeProps = PrivilegeProps;
+export type LanguageProps = z.infer<typeof languagePropsSchema>;
+
+export class Language extends BasePgModel {
+  public readonly name: LanguageProps["name"];
+  public readonly is_trusted: LanguageProps["is_trusted"];
+  public readonly is_procedural: LanguageProps["is_procedural"];
+  public readonly call_handler: LanguageProps["call_handler"];
+  public readonly inline_handler: LanguageProps["inline_handler"];
+  public readonly validator: LanguageProps["validator"];
+  public readonly owner: LanguageProps["owner"];
+  public readonly comment: LanguageProps["comment"];
+  public readonly privileges: LanguagePrivilegeProps[];
+
+  constructor(props: LanguageProps) {
+    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(): `language:${string}` {
+    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(pool: Pool): Promise<Language[]> {
+  const { rows: languageRows } = await pool.query<LanguageProps>(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: unknown) =>
+    languagePropsSchema.parse(row),
+  );
+  return validatedRows.map((row: LanguageProps) => new Language(row));
+}

package/src/core/objects/materialized-view/changes/materialized-view.alter.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import {
+  MaterializedView,
+  type MaterializedViewProps,
+} from "../materialized-view.model.ts";
+import {
+  AlterMaterializedViewChangeOwner,
+  AlterMaterializedViewSetStorageParams,
+} from "./materialized-view.alter.ts";
+
+describe.concurrent("materialized-view", () => {
+  describe("alter", () => {
+    test("change owner", async () => {
+      const props: Omit<MaterializedViewProps, "owner"> = {
+        schema: "public",
+        name: "test_mv",
+        definition: "SELECT * FROM test_table",
+        row_security: false,
+        force_row_security: false,
+        has_indexes: false,
+        has_rules: false,
+        has_triggers: false,
+        has_subclasses: false,
+        is_populated: true,
+        replica_identity: "d",
+        is_partition: false,
+        options: null,
+        partition_bound: null,
+        comment: null,
+        columns: [],
+        privileges: [],
+      };
+      const materializedView = new MaterializedView({
+        ...props,
+        owner: "old_owner",
+      });
+
+      const change = new AlterMaterializedViewChangeOwner({
+        materializedView,
+        owner: "new_owner",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER MATERIALIZED VIEW public.test_mv OWNER TO new_owner",
+      );
+    });
+
+    test("set storage params", async () => {
+      const props: Omit<MaterializedViewProps, "options"> = {
+        schema: "public",
+        name: "test_mv",
+        definition: "SELECT * FROM test_table",
+        row_security: false,
+        force_row_security: false,
+        has_indexes: false,
+        has_rules: false,
+        has_triggers: false,
+        has_subclasses: false,
+        is_populated: true,
+        replica_identity: "d",
+        is_partition: false,
+        partition_bound: null,
+        owner: "test",
+        comment: null,
+        columns: [],
+        privileges: [],
+      };
+      const materializedView = new MaterializedView({
+        ...props,
+        options: [],
+      });
+
+      const change = new AlterMaterializedViewSetStorageParams({
+        materializedView,
+        paramsToSet: ["fillfactor=90"],
+        keysToReset: [],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER MATERIALIZED VIEW public.test_mv SET (fillfactor=90)",
+      );
+    });
+
+    test("reset and set storage params", async () => {
+      const props: Omit<MaterializedViewProps, "options"> = {
+        schema: "public",
+        name: "test_mv",
+        definition: "SELECT * FROM test_table",
+        row_security: false,
+        force_row_security: false,
+        has_indexes: false,
+        has_rules: false,
+        has_triggers: false,
+        has_subclasses: false,
+        is_populated: true,
+        replica_identity: "d",
+        is_partition: false,
+        partition_bound: null,
+        owner: "test",
+        comment: null,
+        columns: [],
+        privileges: [],
+      };
+      const materializedView = new MaterializedView({
+        ...props,
+        options: ["fillfactor=70", "autovacuum_enabled=false"],
+      });
+
+      const change = new AlterMaterializedViewSetStorageParams({
+        materializedView,
+        paramsToSet: ["fillfactor=90", "user_catalog_table=true"],
+        keysToReset: ["autovacuum_enabled"],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        [
+          "ALTER MATERIALIZED VIEW public.test_mv RESET (autovacuum_enabled)",
+          "ALTER MATERIALIZED VIEW public.test_mv SET (fillfactor=90, user_catalog_table=true)",
+        ].join(";\n"),
+      );
+    });
+  });
+});

package/src/core/objects/materialized-view/changes/materialized-view.alter.ts

@@ -0,0 +1,114 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+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 class AlterMaterializedViewChangeOwner extends AlterMaterializedViewChange {
+  public readonly materializedView: MaterializedView;
+  public readonly owner: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { materializedView: MaterializedView; owner: string }) {
+    super();
+    this.materializedView = props.materializedView;
+    this.owner = props.owner;
+  }
+
+  get requires() {
+    return [this.materializedView.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    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 {
+  public readonly materializedView: MaterializedView;
+  public readonly paramsToSet: string[];
+  public readonly keysToReset: string[];
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    materializedView: MaterializedView;
+    paramsToSet: string[];
+    keysToReset: string[];
+  }) {
+    super();
+    this.materializedView = props.materializedView;
+    this.paramsToSet = props.paramsToSet;
+    this.keysToReset = props.keysToReset;
+  }
+
+  get requires() {
+    return [this.materializedView.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const head = [
+      "ALTER MATERIALIZED VIEW",
+      `${this.materializedView.schema}.${this.materializedView.name}`,
+    ].join(" ");
+
+    const statements: string[] = [];
+    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/src/core/objects/materialized-view/changes/materialized-view.base.ts

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

package/src/core/objects/materialized-view/changes/materialized-view.comment.ts

@@ -0,0 +1,177 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { quoteLiteral } from "../../base.change.ts";
+import type { ColumnProps } from "../../base.model.ts";
+import { stableId } from "../../utils.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 class CreateCommentOnMaterializedView extends CreateMaterializedViewChange {
+  public readonly materializedView: MaterializedView;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { materializedView: MaterializedView }) {
+    super();
+    this.materializedView = props.materializedView;
+  }
+
+  get creates() {
+    return [stableId.comment(this.materializedView.stableId)];
+  }
+
+  get requires() {
+    return [this.materializedView.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    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 {
+  public readonly materializedView: MaterializedView;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { materializedView: MaterializedView }) {
+    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(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON MATERIALIZED VIEW",
+      `${this.materializedView.schema}.${this.materializedView.name}`,
+      "IS NULL",
+    ].join(" ");
+  }
+}
+
+export class CreateCommentOnMaterializedViewColumn extends CreateMaterializedViewChange {
+  public readonly materializedView: MaterializedView;
+  public readonly column: ColumnProps;
+  public readonly scope = "comment" as const;
+
+  constructor(props: {
+    materializedView: MaterializedView;
+    column: ColumnProps;
+  }) {
+    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(_options?: SerializeOptions): string {
+    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 {
+  public readonly materializedView: MaterializedView;
+  public readonly column: ColumnProps;
+  public readonly scope = "comment" as const;
+
+  constructor(props: {
+    materializedView: MaterializedView;
+    column: ColumnProps;
+  }) {
+    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(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON COLUMN",
+      `${this.materializedView.schema}.${this.materializedView.name}.${this.column.name}`,
+      "IS NULL",
+    ].join(" ");
+  }
+}

package/src/core/objects/materialized-view/changes/materialized-view.create.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { MaterializedView } from "../materialized-view.model.ts";
+import { CreateMaterializedView } from "./materialized-view.create.ts";
+
+describe("materialized-view", () => {
+  test("create minimal", async () => {
+    const mv = new MaterializedView({
+      schema: "public",
+      name: "test_mv",
+      definition: "SELECT * FROM test_table",
+      row_security: false,
+      force_row_security: false,
+      has_indexes: false,
+      has_rules: false,
+      has_triggers: false,
+      has_subclasses: false,
+      // Default is WITH NO DATA -> omitted
+      is_populated: false,
+      replica_identity: "d",
+      is_partition: false,
+      options: null,
+      partition_bound: null,
+      owner: "test",
+      columns: [],
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateMaterializedView({ materializedView: mv });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE MATERIALIZED VIEW public.test_mv AS SELECT * FROM test_table WITH NO DATA",
+    );
+  });
+
+  test("create with all options", async () => {
+    const mv = new MaterializedView({
+      schema: "public",
+      name: "test_mv",
+      definition: "SELECT * FROM test_table",
+      row_security: false,
+      force_row_security: false,
+      has_indexes: false,
+      has_rules: false,
+      has_triggers: false,
+      has_subclasses: false,
+      is_populated: true,
+      replica_identity: "d",
+      is_partition: false,
+      options: ["fillfactor=90", "autovacuum_enabled=false"],
+      partition_bound: null,
+      owner: "test",
+      columns: [],
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateMaterializedView({ materializedView: mv });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE MATERIALIZED VIEW public.test_mv WITH (fillfactor=90, autovacuum_enabled=false) AS SELECT * FROM test_table WITH DATA",
+    );
+  });
+});