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

package/src/core/objects/materialized-view/materialized-view.diff.ts

@@ -0,0 +1,451 @@
+import type { DefaultPrivilegeState } from "../base.default-privileges.ts";
+import { diffObjects } from "../base.diff.ts";
+import {
+  diffPrivileges,
+  groupPrivilegesByColumns,
+} from "../base.privilege-diff.ts";
+import type { Role } from "../role/role.model.ts";
+import { deepEqual, hasNonAlterableChanges } from "../utils.ts";
+import {
+  AlterMaterializedViewChangeOwner,
+  AlterMaterializedViewSetStorageParams,
+} from "./changes/materialized-view.alter.ts";
+import {
+  CreateCommentOnMaterializedView,
+  CreateCommentOnMaterializedViewColumn,
+  DropCommentOnMaterializedView,
+  DropCommentOnMaterializedViewColumn,
+} from "./changes/materialized-view.comment.ts";
+import { CreateMaterializedView } from "./changes/materialized-view.create.ts";
+import { DropMaterializedView } from "./changes/materialized-view.drop.ts";
+import {
+  GrantMaterializedViewPrivileges,
+  RevokeGrantOptionMaterializedViewPrivileges,
+  RevokeMaterializedViewPrivileges,
+} from "./changes/materialized-view.privilege.ts";
+import type { MaterializedViewChange } from "./changes/materialized-view.types.ts";
+import type { MaterializedView } from "./materialized-view.model.ts";
+
+/**
+ * Diff two sets of materialized views from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The materialized views in the main catalog.
+ * @param branch - The materialized views in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffMaterializedViews(
+  ctx: {
+    version: number;
+    currentUser: string;
+    defaultPrivilegeState: DefaultPrivilegeState;
+    mainRoles: Record<string, Role>;
+  },
+  main: Record<string, MaterializedView>,
+  branch: Record<string, MaterializedView>,
+): MaterializedViewChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+
+  const changes: MaterializedViewChange[] = [];
+
+  for (const materializedViewId of created) {
+    const mv = branch[materializedViewId];
+    changes.push(
+      new CreateMaterializedView({
+        materializedView: mv,
+      }),
+    );
+
+    // OWNER: If the materialized view should be owned by someone other than the current user,
+    // emit ALTER MATERIALIZED VIEW ... OWNER TO after creation
+    if (mv.owner !== ctx.currentUser) {
+      changes.push(
+        new AlterMaterializedViewChangeOwner({
+          materializedView: mv,
+          owner: mv.owner,
+        }),
+      );
+    }
+
+    // Note: RLS (row_security, force_row_security) is a non-alterable property for materialized views.
+    // If RLS needs to be enabled, the materialized view must be dropped and recreated, which is
+    // handled in the "altered" section when non-alterable properties change.
+
+    // Materialized view comment on creation
+    if (mv.comment !== null) {
+      changes.push(
+        new CreateCommentOnMaterializedView({
+          materializedView: mv,
+        }),
+      );
+    }
+    // Column comments on creation
+    for (const col of mv.columns) {
+      if (col.comment !== null) {
+        changes.push(
+          new CreateCommentOnMaterializedViewColumn({
+            materializedView: mv,
+            column: col,
+          }),
+        );
+      }
+    }
+
+    // PRIVILEGES: For created objects, compare against default privileges state
+    // The migration script will run ALTER DEFAULT PRIVILEGES before CREATE (via constraint spec),
+    // so objects are created with the default privileges state in effect.
+    // We compare default privileges against desired privileges to generate REVOKE/GRANT statements
+    // needed to reach the final desired state.
+    const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(
+      ctx.currentUser,
+      "materialized_view",
+      mv.schema ?? "",
+    );
+    const desiredPrivileges = mv.privileges;
+    // Filter out owner privileges - owner always has ALL privileges implicitly
+    // and shouldn't be compared. Use the materialized view owner as the reference.
+    const privilegeResults = diffPrivileges(
+      effectiveDefaults,
+      desiredPrivileges,
+      mv.owner,
+      ctx.mainRoles,
+    );
+
+    // Generate grant changes
+    for (const [grantee, result] of privilegeResults) {
+      if (result.grants.length > 0) {
+        const grantGroups = groupPrivilegesByColumns(result.grants);
+        for (const [, group] of grantGroups) {
+          for (const [grantable, privSet] of group.byGrant) {
+            const privileges = Array.from(privSet).map((priv) => ({
+              privilege: priv,
+              grantable,
+            }));
+            changes.push(
+              new GrantMaterializedViewPrivileges({
+                materializedView: mv,
+                grantee,
+                privileges,
+                columns: group.columns,
+                version: ctx.version,
+              }),
+            );
+          }
+        }
+      }
+
+      // Generate revoke changes
+      if (result.revokes.length > 0) {
+        const revokeGroups = groupPrivilegesByColumns(result.revokes);
+        for (const [, group] of revokeGroups) {
+          const allPrivileges = new Set<string>();
+          for (const [, privSet] of group.byGrant) {
+            for (const priv of privSet) {
+              allPrivileges.add(priv);
+            }
+          }
+          const privileges = Array.from(allPrivileges).map((priv) => ({
+            privilege: priv,
+            grantable: false,
+          }));
+          changes.push(
+            new RevokeMaterializedViewPrivileges({
+              materializedView: mv,
+              grantee,
+              privileges,
+              columns: group.columns,
+              version: ctx.version,
+            }),
+          );
+        }
+      }
+
+      // Generate revoke grant option changes
+      if (result.revokeGrantOption.length > 0) {
+        const revokeGrantGroups = new Map<
+          string,
+          { columns?: string[]; privileges: Set<string> }
+        >();
+        for (const r of result.revokeGrantOption) {
+          // For revoke grant option, we need to find the columns from the effective defaults
+          const originalPriv = effectiveDefaults.find(
+            (p) => p.grantee === grantee && p.privilege === r,
+          );
+          const key = originalPriv?.columns
+            ? originalPriv.columns.sort().join(",")
+            : "";
+          if (!revokeGrantGroups.has(key)) {
+            revokeGrantGroups.set(key, {
+              columns: originalPriv?.columns
+                ? [...originalPriv.columns]
+                : undefined,
+              privileges: new Set(),
+            });
+          }
+          const group = revokeGrantGroups.get(key);
+          if (!group) continue;
+          group.privileges.add(r);
+        }
+        for (const [, group] of revokeGrantGroups) {
+          const privilegeNames = Array.from(group.privileges);
+          changes.push(
+            new RevokeGrantOptionMaterializedViewPrivileges({
+              materializedView: mv,
+              grantee,
+              privilegeNames,
+              columns: group.columns,
+              version: ctx.version,
+            }),
+          );
+        }
+      }
+    }
+  }
+
+  for (const materializedViewId of dropped) {
+    changes.push(
+      new DropMaterializedView({ materializedView: main[materializedViewId] }),
+    );
+  }
+
+  for (const materializedViewId of altered) {
+    const mainMaterializedView = main[materializedViewId];
+    const branchMaterializedView = branch[materializedViewId];
+
+    // Check if non-alterable properties have changed
+    // These require dropping and recreating the materialized view
+    const NON_ALTERABLE_FIELDS: Array<keyof MaterializedView> = [
+      "definition",
+      "row_security",
+      "force_row_security",
+      "has_indexes",
+      "has_rules",
+      "has_triggers",
+      "has_subclasses",
+      "is_populated",
+      "replica_identity",
+      "is_partition",
+      "partition_bound",
+    ];
+    const nonAlterablePropsChanged = hasNonAlterableChanges(
+      mainMaterializedView,
+      branchMaterializedView,
+      NON_ALTERABLE_FIELDS,
+      { options: deepEqual },
+    );
+
+    if (nonAlterablePropsChanged) {
+      // Replace the entire materialized view (drop + create)
+      changes.push(
+        new DropMaterializedView({ materializedView: mainMaterializedView }),
+        new CreateMaterializedView({
+          materializedView: branchMaterializedView,
+        }),
+      );
+    } else {
+      // Only alterable properties changed - check each one
+
+      // OWNER
+      if (mainMaterializedView.owner !== branchMaterializedView.owner) {
+        changes.push(
+          new AlterMaterializedViewChangeOwner({
+            materializedView: mainMaterializedView,
+            owner: branchMaterializedView.owner,
+          }),
+        );
+      }
+
+      // STORAGE PARAMETERS (reloptions)
+      // Emit a combined SET/RESET change similar to indexes
+      if (
+        !deepEqual(mainMaterializedView.options, branchMaterializedView.options)
+      ) {
+        const parseOptions = (options: string[] | null | undefined) => {
+          const map = new Map<string, string>();
+          if (!options) return map;
+          for (const opt of options) {
+            const eqIndex = opt.indexOf("=");
+            const key = opt.slice(0, eqIndex).trim();
+            const value = opt.slice(eqIndex + 1).trim();
+            map.set(key, value);
+          }
+          return map;
+        };
+        const mainMap = parseOptions(mainMaterializedView.options);
+        const branchMap = parseOptions(branchMaterializedView.options);
+        const keysToReset: string[] = [];
+        for (const key of mainMap.keys()) {
+          if (!branchMap.has(key)) keysToReset.push(key);
+        }
+        const paramsToSet: string[] = [];
+        for (const [key, newValue] of branchMap.entries()) {
+          const oldValue = mainMap.get(key);
+          const changed = oldValue !== newValue;
+          if (changed) {
+            paramsToSet.push(
+              newValue === undefined ? key : `${key}=${newValue}`,
+            );
+          }
+        }
+        changes.push(
+          new AlterMaterializedViewSetStorageParams({
+            materializedView: mainMaterializedView,
+            paramsToSet,
+            keysToReset,
+          }),
+        );
+      }
+
+      // Note: Materialized view renaming would also use ALTER MATERIALIZED VIEW ... RENAME TO ...
+      // But since our MaterializedView model uses 'name' as the identity field,
+      // a name change would be handled as drop + create by diffObjects()
+      // MATERIALIZED VIEW COMMENT (create/drop when comment changes)
+      if (mainMaterializedView.comment !== branchMaterializedView.comment) {
+        if (branchMaterializedView.comment === null) {
+          changes.push(
+            new DropCommentOnMaterializedView({
+              materializedView: mainMaterializedView,
+            }),
+          );
+        } else {
+          changes.push(
+            new CreateCommentOnMaterializedView({
+              materializedView: branchMaterializedView,
+            }),
+          );
+        }
+      }
+      // COMMENT changes on columns
+      const mainCols = new Map(
+        mainMaterializedView.columns.map((c) => [c.name, c]),
+      );
+      const branchCols = new Map(
+        branchMaterializedView.columns.map((c) => [c.name, c]),
+      );
+      for (const [name, branchCol] of branchCols) {
+        const mainCol = mainCols.get(name);
+        if (!mainCol) continue;
+        if (mainCol.comment !== branchCol.comment) {
+          if (branchCol.comment === null) {
+            changes.push(
+              new DropCommentOnMaterializedViewColumn({
+                materializedView: mainMaterializedView,
+                column: mainCol,
+              }),
+            );
+          } else {
+            changes.push(
+              new CreateCommentOnMaterializedViewColumn({
+                materializedView: branchMaterializedView,
+                column: branchCol,
+              }),
+            );
+          }
+        }
+      }
+
+      // PRIVILEGES (unified object and column 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(
+        mainMaterializedView.privileges,
+        branchMaterializedView.privileges,
+        branchMaterializedView.owner,
+        ctx.mainRoles,
+      );
+
+      for (const [grantee, result] of privilegeResults) {
+        // Generate grant changes
+        if (result.grants.length > 0) {
+          const grantGroups = groupPrivilegesByColumns(result.grants);
+          for (const [, group] of grantGroups) {
+            for (const [grantable, privSet] of group.byGrant) {
+              const privileges = Array.from(privSet).map((priv) => ({
+                privilege: priv,
+                grantable,
+              }));
+              changes.push(
+                new GrantMaterializedViewPrivileges({
+                  materializedView: branchMaterializedView,
+                  grantee,
+                  privileges,
+                  columns: group.columns,
+                  version: ctx.version,
+                }),
+              );
+            }
+          }
+        }
+
+        // Generate revoke changes
+        if (result.revokes.length > 0) {
+          const revokeGroups = groupPrivilegesByColumns(result.revokes);
+          for (const [, group] of revokeGroups) {
+            // Collapse all grantable groups into a single revoke (grantable: false)
+            const allPrivileges = new Set<string>();
+            for (const [, privSet] of group.byGrant) {
+              for (const priv of privSet) {
+                allPrivileges.add(priv);
+              }
+            }
+            const privileges = Array.from(allPrivileges).map((priv) => ({
+              privilege: priv,
+              grantable: false,
+            }));
+            changes.push(
+              new RevokeMaterializedViewPrivileges({
+                materializedView: mainMaterializedView,
+                grantee,
+                privileges,
+                columns: group.columns,
+                version: ctx.version,
+              }),
+            );
+          }
+        }
+
+        // Generate revoke grant option changes
+        if (result.revokeGrantOption.length > 0) {
+          const revokeGrantGroups = new Map<
+            string,
+            { columns?: string[]; privileges: Set<string> }
+          >();
+          for (const r of result.revokeGrantOption) {
+            // For revoke grant option, we need to find the columns from the original privilege
+            const originalPriv = mainMaterializedView.privileges.find(
+              (p) => p.grantee === grantee && p.privilege === r,
+            );
+            const key = originalPriv?.columns
+              ? originalPriv.columns.sort().join(",")
+              : "";
+            if (!revokeGrantGroups.has(key)) {
+              revokeGrantGroups.set(key, {
+                columns: originalPriv?.columns
+                  ? [...originalPriv.columns]
+                  : undefined,
+                privileges: new Set(),
+              });
+            }
+            const group = revokeGrantGroups.get(key);
+            if (!group) continue;
+            group.privileges.add(r);
+          }
+          for (const [, group] of revokeGrantGroups) {
+            const privilegeNames = Array.from(group.privileges);
+            changes.push(
+              new RevokeGrantOptionMaterializedViewPrivileges({
+                materializedView: mainMaterializedView,
+                grantee,
+                privilegeNames,
+                columns: group.columns,
+                version: ctx.version,
+              }),
+            );
+          }
+        }
+      }
+    }
+  }
+
+  return changes;
+}

package/src/core/objects/materialized-view/materialized-view.model.ts

@@ -0,0 +1,258 @@
+import { sql } from "@ts-safeql/sql-tag";
+import type { Pool } from "pg";
+import z from "zod";
+import {
+  BasePgModel,
+  columnPropsSchema,
+  type TableLikeObject,
+} from "../base.model.ts";
+import {
+  type PrivilegeProps,
+  privilegePropsSchema,
+} from "../base.privilege-diff.ts";
+import { ReplicaIdentitySchema } from "../table/table.model.ts";
+
+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),
+});
+
+type MaterializedViewPrivilegeProps = PrivilegeProps;
+export type MaterializedViewProps = z.infer<typeof materializedViewPropsSchema>;
+
+export class MaterializedView extends BasePgModel implements TableLikeObject {
+  public readonly schema: MaterializedViewProps["schema"];
+  public readonly name: MaterializedViewProps["name"];
+  public readonly definition: MaterializedViewProps["definition"];
+  public readonly row_security: MaterializedViewProps["row_security"];
+  public readonly force_row_security: MaterializedViewProps["force_row_security"];
+  public readonly has_indexes: MaterializedViewProps["has_indexes"];
+  public readonly has_rules: MaterializedViewProps["has_rules"];
+  public readonly has_triggers: MaterializedViewProps["has_triggers"];
+  public readonly has_subclasses: MaterializedViewProps["has_subclasses"];
+  public readonly is_populated: MaterializedViewProps["is_populated"];
+  public readonly replica_identity: MaterializedViewProps["replica_identity"];
+  public readonly is_partition: MaterializedViewProps["is_partition"];
+  public readonly options: MaterializedViewProps["options"];
+  public readonly partition_bound: MaterializedViewProps["partition_bound"];
+  public readonly owner: MaterializedViewProps["owner"];
+  public readonly comment: MaterializedViewProps["comment"];
+  public readonly columns: MaterializedViewProps["columns"];
+  public readonly privileges: MaterializedViewPrivilegeProps[];
+
+  constructor(props: MaterializedViewProps) {
+    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(): `materializedView:${string}` {
+    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,
+    };
+  }
+
+  override stableSnapshot() {
+    const normalizeColumns = () =>
+      [...this.columns]
+        .map((col) => {
+          const { position: _pos, ...rest } = col as unknown as Record<
+            string,
+            unknown
+          >;
+          return rest;
+        })
+        .sort((a, b) => {
+          const nameA = (a.name as string | undefined) ?? "";
+          const nameB = (b.name as string | undefined) ?? "";
+          return nameA.localeCompare(nameB);
+        });
+
+    return {
+      identity: this.identityFields,
+      data: {
+        ...this.dataFields,
+        columns: normalizeColumns(),
+      },
+    };
+  }
+}
+
+export async function extractMaterializedViews(
+  pool: Pool,
+): Promise<MaterializedView[]> {
+  const { rows: mvRows } = await pool.query<MaterializedViewProps>(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: unknown) =>
+    materializedViewPropsSchema.parse(row),
+  );
+  return validatedRows.map(
+    (row: MaterializedViewProps) => new MaterializedView(row),
+  );
+}