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

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

@@ -0,0 +1,270 @@
+import { diffObjects } from "../base.diff.js";
+import { diffPrivileges, groupPrivilegesByColumns, } from "../base.privilege-diff.js";
+import { deepEqual, hasNonAlterableChanges } from "../utils.js";
+import { AlterViewChangeOwner, AlterViewResetOptions, AlterViewSetOptions, } from "./changes/view.alter.js";
+import { CreateCommentOnView, DropCommentOnView, } from "./changes/view.comment.js";
+import { CreateView } from "./changes/view.create.js";
+import { DropView } from "./changes/view.drop.js";
+import { GrantViewPrivileges, RevokeGrantOptionViewPrivileges, RevokeViewPrivileges, } from "./changes/view.privilege.js";
+/**
+ * Diff two sets of views from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The views in the main catalog.
+ * @param branch - The views in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffViews(ctx, main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const viewId of created) {
+        const v = branch[viewId];
+        changes.push(new CreateView({ view: v }));
+        // OWNER: If the view should be owned by someone other than the current user,
+        // emit ALTER VIEW ... OWNER TO after creation
+        if (v.owner !== ctx.currentUser) {
+            changes.push(new AlterViewChangeOwner({ view: v, owner: v.owner }));
+        }
+        if (v.comment !== null) {
+            changes.push(new CreateCommentOnView({ view: v }));
+        }
+        // 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, "view", v.schema ?? "");
+        const desiredPrivileges = v.privileges;
+        // Filter out owner privileges - owner always has ALL privileges implicitly
+        // and shouldn't be compared. Use the view owner as the reference.
+        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, v.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 GrantViewPrivileges({
+                            view: v,
+                            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();
+                    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 RevokeViewPrivileges({
+                        view: v,
+                        grantee,
+                        privileges,
+                        columns: group.columns,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            // Generate revoke grant option changes
+            if (result.revokeGrantOption.length > 0) {
+                const revokeGrantGroups = new Map();
+                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 RevokeGrantOptionViewPrivileges({
+                        view: v,
+                        grantee,
+                        privilegeNames,
+                        columns: group.columns,
+                        version: ctx.version,
+                    }));
+                }
+            }
+        }
+    }
+    for (const viewId of dropped) {
+        changes.push(new DropView({ view: main[viewId] }));
+    }
+    for (const viewId of altered) {
+        const mainView = main[viewId];
+        const branchView = branch[viewId];
+        // Check if non-alterable properties have changed
+        // These require dropping and recreating the view
+        const NON_ALTERABLE_FIELDS = [
+            "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(mainView, branchView, NON_ALTERABLE_FIELDS, { options: deepEqual });
+        if (nonAlterablePropsChanged) {
+            // Replace the entire view using CREATE OR REPLACE to avoid drop when possible
+            changes.push(new CreateView({ view: branchView, orReplace: true }));
+        }
+        else {
+            // Only alterable properties changed - check each one
+            // OWNER
+            if (mainView.owner !== branchView.owner) {
+                changes.push(new AlterViewChangeOwner({ view: mainView, owner: branchView.owner }));
+            }
+            // VIEW OPTIONS (WITH (...))
+            if (!deepEqual(mainView.options, branchView.options)) {
+                const mainOpts = mainView.options ?? [];
+                const branchOpts = branchView.options ?? [];
+                // Always set branch options when provided
+                if (branchOpts.length > 0) {
+                    changes.push(new AlterViewSetOptions({ view: mainView, options: branchOpts }));
+                }
+                // Reset any params that are present in main but absent in branch
+                if (mainOpts.length > 0) {
+                    const mainNames = new Set(mainOpts.map((opt) => opt.split("=")[0]));
+                    const branchNames = new Set(branchOpts.map((opt) => opt.split("=")[0]));
+                    const removed = [];
+                    for (const name of mainNames) {
+                        if (!branchNames.has(name))
+                            removed.push(name);
+                    }
+                    if (removed.length > 0) {
+                        changes.push(new AlterViewResetOptions({ view: mainView, params: removed }));
+                    }
+                }
+            }
+            // COMMENT
+            if (mainView.comment !== branchView.comment) {
+                if (branchView.comment === null) {
+                    changes.push(new DropCommentOnView({ view: mainView }));
+                }
+                else {
+                    changes.push(new CreateCommentOnView({ view: branchView }));
+                }
+            }
+            // Note: View renaming would also use ALTER VIEW ... RENAME TO ...
+            // But since our View model uses 'name' as the identity field,
+            // a name change would be handled as drop + create by diffObjects()
+            // 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(mainView.privileges, branchView.privileges, branchView.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 GrantViewPrivileges({
+                                view: branchView,
+                                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();
+                        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 RevokeViewPrivileges({
+                            view: mainView,
+                            grantee,
+                            privileges,
+                            columns: group.columns,
+                            version: ctx.version,
+                        }));
+                    }
+                }
+                // Generate revoke grant option changes
+                if (result.revokeGrantOption.length > 0) {
+                    const revokeGrantGroups = new Map();
+                    for (const r of result.revokeGrantOption) {
+                        // For revoke grant option, we need to find the columns from the original privilege
+                        const originalPriv = mainView.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 RevokeGrantOptionViewPrivileges({
+                            view: mainView,
+                            grantee,
+                            privilegeNames,
+                            columns: group.columns,
+                            version: ctx.version,
+                        }));
+                    }
+                }
+            }
+        }
+    }
+    return changes;
+}

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

@@ -0,0 +1,152 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel, type TableLikeObject } from "../base.model.ts";
+import { type PrivilegeProps } from "../base.privilege-diff.ts";
+declare const viewPropsSchema: z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+    definition: z.ZodString;
+    row_security: z.ZodBoolean;
+    force_row_security: z.ZodBoolean;
+    has_indexes: z.ZodBoolean;
+    has_rules: z.ZodBoolean;
+    has_triggers: z.ZodBoolean;
+    has_subclasses: z.ZodBoolean;
+    is_populated: z.ZodBoolean;
+    replica_identity: z.ZodEnum<{
+        n: "n";
+        i: "i";
+        d: "d";
+        f: "f";
+    }>;
+    is_partition: z.ZodBoolean;
+    options: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    partition_bound: z.ZodNullable<z.ZodString>;
+    owner: z.ZodString;
+    comment: z.ZodNullable<z.ZodString>;
+    columns: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        position: z.ZodNumber;
+        data_type: z.ZodString;
+        data_type_str: z.ZodString;
+        is_custom_type: z.ZodBoolean;
+        custom_type_type: z.ZodNullable<z.ZodString>;
+        custom_type_category: z.ZodNullable<z.ZodString>;
+        custom_type_schema: z.ZodNullable<z.ZodString>;
+        custom_type_name: z.ZodNullable<z.ZodString>;
+        not_null: z.ZodBoolean;
+        is_identity: z.ZodBoolean;
+        is_identity_always: z.ZodBoolean;
+        is_generated: z.ZodBoolean;
+        collation: z.ZodNullable<z.ZodString>;
+        default: z.ZodNullable<z.ZodString>;
+        comment: z.ZodNullable<z.ZodString>;
+    }, z.z.core.$strip>>;
+    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 ViewPrivilegeProps = PrivilegeProps;
+export type ViewProps = z.infer<typeof viewPropsSchema>;
+export declare class View extends BasePgModel implements TableLikeObject {
+    readonly schema: ViewProps["schema"];
+    readonly name: ViewProps["name"];
+    readonly definition: ViewProps["definition"];
+    readonly row_security: ViewProps["row_security"];
+    readonly force_row_security: ViewProps["force_row_security"];
+    readonly has_indexes: ViewProps["has_indexes"];
+    readonly has_rules: ViewProps["has_rules"];
+    readonly has_triggers: ViewProps["has_triggers"];
+    readonly has_subclasses: ViewProps["has_subclasses"];
+    readonly is_populated: ViewProps["is_populated"];
+    readonly replica_identity: ViewProps["replica_identity"];
+    readonly is_partition: ViewProps["is_partition"];
+    readonly options: ViewProps["options"];
+    readonly partition_bound: ViewProps["partition_bound"];
+    readonly owner: ViewProps["owner"];
+    readonly comment: ViewProps["comment"];
+    readonly columns: ViewProps["columns"];
+    readonly privileges: ViewPrivilegeProps[];
+    constructor(props: ViewProps);
+    get stableId(): `view:${string}`;
+    get identityFields(): {
+        schema: string;
+        name: string;
+    };
+    get dataFields(): {
+        definition: string;
+        row_security: boolean;
+        force_row_security: boolean;
+        has_indexes: boolean;
+        has_rules: boolean;
+        has_triggers: boolean;
+        has_subclasses: boolean;
+        is_populated: boolean;
+        replica_identity: "n" | "i" | "d" | "f";
+        is_partition: boolean;
+        options: string[] | null;
+        partition_bound: string | null;
+        owner: string;
+        comment: string | null;
+        columns: {
+            name: string;
+            position: number;
+            data_type: string;
+            data_type_str: string;
+            is_custom_type: boolean;
+            custom_type_type: string | null;
+            custom_type_category: string | null;
+            custom_type_schema: string | null;
+            custom_type_name: string | null;
+            not_null: boolean;
+            is_identity: boolean;
+            is_identity_always: boolean;
+            is_generated: boolean;
+            collation: string | null;
+            default: string | null;
+            comment: string | null;
+        }[];
+        privileges: {
+            grantee: string;
+            privilege: string;
+            grantable: boolean;
+            columns?: string[] | null | undefined;
+        }[];
+    };
+    stableSnapshot(): {
+        identity: {
+            schema: string;
+            name: string;
+        };
+        data: {
+            columns: {
+                [x: string]: unknown;
+            }[];
+            definition: string;
+            row_security: boolean;
+            force_row_security: boolean;
+            has_indexes: boolean;
+            has_rules: boolean;
+            has_triggers: boolean;
+            has_subclasses: boolean;
+            is_populated: boolean;
+            replica_identity: "n" | "i" | "d" | "f";
+            is_partition: boolean;
+            options: string[] | null;
+            partition_bound: string | null;
+            owner: string;
+            comment: string | null;
+            privileges: {
+                grantee: string;
+                privilege: string;
+                grantable: boolean;
+                columns?: string[] | null | undefined;
+            }[];
+        };
+    };
+}
+export declare function extractViews(sql: Sql): Promise<View[]>;
+export {};

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

@@ -0,0 +1,250 @@
+import z from "zod";
+import { BasePgModel, columnPropsSchema, } from "../base.model.js";
+import { privilegePropsSchema, } from "../base.privilege-diff.js";
+import { ReplicaIdentitySchema } from "../table/table.model.js";
+const viewPropsSchema = z.object({
+    schema: z.string(),
+    name: z.string(),
+    definition: z.string(),
+    row_security: z.boolean(),
+    force_row_security: z.boolean(),
+    has_indexes: z.boolean(),
+    has_rules: z.boolean(),
+    has_triggers: z.boolean(),
+    has_subclasses: z.boolean(),
+    is_populated: z.boolean(),
+    replica_identity: ReplicaIdentitySchema,
+    is_partition: z.boolean(),
+    options: z.array(z.string()).nullable(),
+    partition_bound: z.string().nullable(),
+    owner: z.string(),
+    comment: z.string().nullable(),
+    columns: z.array(columnPropsSchema),
+    privileges: z.array(privilegePropsSchema),
+});
+export class View extends BasePgModel {
+    schema;
+    name;
+    definition;
+    row_security;
+    force_row_security;
+    has_indexes;
+    has_rules;
+    has_triggers;
+    has_subclasses;
+    is_populated;
+    replica_identity;
+    is_partition;
+    options;
+    partition_bound;
+    owner;
+    comment;
+    columns;
+    privileges;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.schema = props.schema;
+        this.name = props.name;
+        // Data fields
+        this.definition = props.definition;
+        this.row_security = props.row_security;
+        this.force_row_security = props.force_row_security;
+        this.has_indexes = props.has_indexes;
+        this.has_rules = props.has_rules;
+        this.has_triggers = props.has_triggers;
+        this.has_subclasses = props.has_subclasses;
+        this.is_populated = props.is_populated;
+        this.replica_identity = props.replica_identity;
+        this.is_partition = props.is_partition;
+        this.options = props.options;
+        this.partition_bound = props.partition_bound;
+        this.owner = props.owner;
+        this.comment = props.comment;
+        this.columns = props.columns;
+        this.privileges = props.privileges;
+    }
+    get stableId() {
+        return `view:${this.schema}.${this.name}`;
+    }
+    get identityFields() {
+        return {
+            schema: this.schema,
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            definition: this.definition,
+            row_security: this.row_security,
+            force_row_security: this.force_row_security,
+            has_indexes: this.has_indexes,
+            has_rules: this.has_rules,
+            has_triggers: this.has_triggers,
+            has_subclasses: this.has_subclasses,
+            is_populated: this.is_populated,
+            replica_identity: this.replica_identity,
+            is_partition: this.is_partition,
+            options: this.options,
+            partition_bound: this.partition_bound,
+            owner: this.owner,
+            comment: this.comment,
+            columns: this.columns,
+            privileges: this.privileges,
+        };
+    }
+    stableSnapshot() {
+        const normalizeColumns = () => [...this.columns]
+            .map((col) => {
+            const { position: _pos, ...rest } = col;
+            return rest;
+        })
+            .sort((a, b) => {
+            const nameA = a.name ?? "";
+            const nameB = b.name ?? "";
+            return nameA.localeCompare(nameB);
+        });
+        return {
+            identity: this.identityFields,
+            data: {
+                ...this.dataFields,
+                columns: normalizeColumns(),
+            },
+        };
+    }
+}
+export async function extractViews(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const viewRows = await sql `
+with extension_oids as (
+  select
+    objid
+  from
+    pg_depend d
+  where
+    d.refclassid = 'pg_extension'::regclass
+    and d.classid = 'pg_class'::regclass
+), views as (
+  select
+    c.relnamespace::regnamespace::text as schema,
+    quote_ident(c.relname) as name,
+    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,
+    c.oid as oid
+  from
+    pg_catalog.pg_class c
+    left outer join extension_oids e on c.oid = e.objid
+  where not c.relnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+    and e.objid is null
+    and c.relkind = 'v'
+)
+select
+  v.schema,
+  v.name,
+  v.definition,
+  v.row_security,
+  v.force_row_security,
+  v.has_indexes,
+  v.has_rules,
+  v.has_triggers,
+  v.has_subclasses,
+  v.is_populated,
+  v.replica_identity,
+  v.is_partition,
+  v.options,
+  v.partition_bound,
+  v.owner,
+  v.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, v.oid as relacl_oid, (
+          select c_rel.relacl from pg_class c_rel where c_rel.oid = v.oid
+        ) as acl
+        union all
+        select a2.attname, v.oid as relacl_oid, a2.attacl
+        from pg_attribute a2
+        where a2.attrelid = v.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
+  views v
+  left join pg_attribute a on a.attrelid = v.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
+group by
+  v.oid, v.schema, v.name, v.definition, v.row_security, v.force_row_security, v.has_indexes, v.has_rules, v.has_triggers, v.has_subclasses, v.is_populated, v.replica_identity, v.is_partition, v.options, v.partition_bound, v.owner, v.comment
+order by
+  v.schema, v.name;
+    `;
+        // Validate and parse each row using the Zod schema
+        const validatedRows = viewRows.map((row) => viewPropsSchema.parse(row));
+        return validatedRows.map((row) => new View(row));
+    });
+}