@mikeatlast/ponder 0.16.1-fork.1

package/dist/esm/drizzle/kit/index.js

@@ -0,0 +1,927 @@
+import { SQL, is, sql } from "drizzle-orm";
+import { CasingCache, toCamelCase, toSnakeCase } from "drizzle-orm/casing";
+import { PgColumn, PgDialect, PgEnumColumn, PgMaterializedView, PgSchema, PgTable, PgView, getTableConfig, getViewConfig, index, integer, isPgEnum, isPgSequence, pgSchema, pgTable, varchar, } from "drizzle-orm/pg-core";
+import { getReorgSequenceName, getReorgTableName } from "../onchain.js";
+export const getReorgTable = (table) => {
+    const schema = getTableConfig(table).schema;
+    if (schema && schema !== "public") {
+        return pgSchema(schema).table(getReorgTableName(table), {
+            operation_id: integer()
+                .notNull()
+                .primaryKey()
+                .default(sql.raw(`nextval('"${schema}"."${getReorgSequenceName()}"')`)),
+            operation: integer().notNull().$type(),
+            checkpoint: varchar({ length: 75 }).notNull(),
+        }, (table) => [index().on(table.checkpoint)]);
+    }
+    return pgTable(getReorgTableName(table), {
+        operation_id: integer()
+            .notNull()
+            .primaryKey()
+            .default(sql.raw(`nextval('"${getReorgSequenceName()}"')`)),
+        operation: integer().notNull().$type(),
+        checkpoint: varchar({ length: 75 }).notNull(),
+    }, (table) => [index().on(table.checkpoint)]);
+};
+export const getSql = (schema) => {
+    const { tables, views, enums, schemas } = prepareFromExports(schema);
+    const json = generatePgSnapshot(tables, views, enums, schemas, "snake_case");
+    const squashed = squashPgScheme(json);
+    const jsonCreateIndexesForCreatedTables = Object.values(squashed.tables).flatMap((it) => {
+        // @ts-ignore
+        return preparePgCreateIndexesJson(it.name, it.schema, it.indexes);
+    });
+    const jsonCreateEnums = Object.values(squashed.enums).map((it) => {
+        // @ts-ignore
+        return prepareCreateEnumJson(it.name, it.schema, it.values);
+    }) ?? [];
+    const jsonCreateTables = Object.values(squashed.tables).map((it) => {
+        return preparePgCreateTableJson(it, json);
+    });
+    const jsonCreateViews = Object.values(squashed.views).map((it) => {
+        return preparePgCreateViewJson(it.name, it.schema, it.definition, it.materialized, it.withNoData, it.with, it.using, it.tablespace);
+    });
+    const fromJson = (statements) => statements
+        .flatMap((statement) => {
+        const filtered = convertors.filter((it) => {
+            return it.can(statement, "postgresql");
+        });
+        const convertor = filtered.length === 1 ? filtered[0] : undefined;
+        if (!convertor) {
+            return "";
+        }
+        return convertor.convert(statement);
+    })
+        .filter((it) => it !== "");
+    const combinedTables = jsonCreateTables.flatMap((statement) => [
+        statement,
+        createReorgTableStatement(statement),
+    ]);
+    return {
+        tables: {
+            sql: fromJson(combinedTables),
+            json: combinedTables,
+        },
+        views: { sql: fromJson(jsonCreateViews), json: jsonCreateViews },
+        enums: { sql: fromJson(jsonCreateEnums), json: jsonCreateEnums },
+        indexes: {
+            sql: fromJson(jsonCreateIndexesForCreatedTables),
+            json: jsonCreateIndexesForCreatedTables,
+        },
+    };
+};
+const createReorgTableStatement = (statement) => {
+    const reorgStatement = structuredClone(statement);
+    reorgStatement.compositePkName = undefined;
+    reorgStatement.compositePKs = [];
+    for (const column of reorgStatement.columns) {
+        column.primaryKey = false;
+    }
+    const reorgColumns = Object.values(squashPgScheme(generatePgSnapshot([
+        pgTable("", {
+            operation_id: integer()
+                .notNull()
+                .primaryKey()
+                .default(sql.raw(`nextval('"${statement.schema === "" ? "public" : statement.schema}"."${getReorgSequenceName()}"')`)),
+            operation: integer().notNull(),
+            checkpoint: varchar({ length: 75 }).notNull(),
+        }),
+    ], [], [], [], "snake_case")).tables)[0].columns;
+    reorgStatement.columns.push(...Object.values(reorgColumns));
+    reorgStatement.tableName = getReorgTableName(reorgStatement.tableName);
+    return reorgStatement;
+};
+const PgSquasher = {
+    squashIdx: (idx) => {
+        return `${idx.name};${idx.columns
+            .map((c) => `${c.expression}--${c.isExpression}--${c.asc}--${c.nulls}--${c.opclass && ""}`)
+            .join(",,")};${idx.isUnique};${idx.concurrently};${idx.method};${idx.where};${JSON.stringify(idx.with)}`;
+    },
+    unsquashIdx: (input) => {
+        const [name, columnsString, isUnique, concurrently, method, where, idxWith,] = input.split(";");
+        const columnString = columnsString.split(",,");
+        const columns = [];
+        for (const column of columnString) {
+            const [expression, isExpression, asc, nulls, opclass] = column.split("--");
+            columns.push({
+                nulls: nulls,
+                isExpression: isExpression === "true",
+                asc: asc === "true",
+                expression: expression,
+                opclass: opclass === "undefined" ? undefined : opclass,
+            });
+        }
+        return {
+            name,
+            columns,
+            isUnique: isUnique === "true",
+            concurrently: concurrently === "true",
+            method,
+            where: where === "undefined" ? undefined : where,
+            with: !idxWith || idxWith === "undefined" ? undefined : JSON.parse(idxWith),
+        };
+    },
+    squashPK: (pk) => {
+        return `${pk.columns.join(",")};${pk.name}`;
+    },
+    unsquashPK: (pk) => {
+        const splitted = pk.split(";");
+        return { name: splitted[1], columns: splitted[0].split(",") };
+    },
+};
+////////
+// Generator
+////////
+const parseType = (schemaPrefix, type) => {
+    const pgNativeTypes = [
+        "uuid",
+        "smallint",
+        "integer",
+        "bigint",
+        "boolean",
+        "text",
+        "varchar",
+        "serial",
+        "bigserial",
+        "decimal",
+        "numeric",
+        "real",
+        "json",
+        "jsonb",
+        "time",
+        "time with time zone",
+        "time without time zone",
+        "time",
+        "timestamp",
+        "timestamp with time zone",
+        "timestamp without time zone",
+        "date",
+        "interval",
+        "bigint",
+        "bigserial",
+        "double precision",
+        "interval year",
+        "interval month",
+        "interval day",
+        "interval hour",
+        "interval minute",
+        "interval second",
+        "interval year to month",
+        "interval day to hour",
+        "interval day to minute",
+        "interval day to second",
+        "interval hour to minute",
+        "interval hour to second",
+        "interval minute to second",
+    ];
+    const arrayDefinitionRegex = /\[\d*(?:\[\d*\])*\]/g;
+    const arrayDefinition = (type.match(arrayDefinitionRegex) ?? []).join("");
+    const withoutArrayDefinition = type.replace(arrayDefinitionRegex, "");
+    return pgNativeTypes.some((it) => type.startsWith(it))
+        ? `${withoutArrayDefinition}${arrayDefinition}`
+        : `${schemaPrefix}"${withoutArrayDefinition}"${arrayDefinition}`;
+};
+class Convertor {
+}
+class PgCreateTableConvertor extends Convertor {
+    can(statement, dialect) {
+        return statement.type === "create_table" && dialect === "postgresql";
+    }
+    convert(st) {
+        const { tableName, schema, columns, compositePKs } = st;
+        let statement = "";
+        const name = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
+        statement += `CREATE TABLE ${name} (\n`;
+        for (let i = 0; i < columns.length; i++) {
+            const column = columns[i];
+            const primaryKeyStatement = column.primaryKey ? " PRIMARY KEY" : "";
+            const notNullStatement = column.notNull && !column.identity ? " NOT NULL" : "";
+            const defaultStatement = column.default !== undefined ? ` DEFAULT ${column.default}` : "";
+            // const uniqueConstraint = column.isUnique
+            //   ? ` CONSTRAINT "${column.uniqueName}" UNIQUE${column.nullsNotDistinct ? " NULLS NOT DISTINCT" : ""}`
+            //   : "";
+            const schemaPrefix = column.typeSchema && column.typeSchema !== "public"
+                ? `"${column.typeSchema}".`
+                : "";
+            const type = parseType(schemaPrefix, column.type);
+            // const generated = column.generated;
+            // const generatedStatement = generated
+            //   ? ` GENERATED ALWAYS AS (${generated?.as}) STORED`
+            //   : "";
+            // const unsquashedIdentity = column.identity
+            //   ? PgSquasher.unsquashIdentity(column.identity)
+            //   : undefined;
+            // const identityWithSchema = schema
+            //   ? `"${schema}"."${unsquashedIdentity?.name}"`
+            //   : `"${unsquashedIdentity?.name}"`;
+            // const identity = unsquashedIdentity
+            //   ? ` GENERATED ${
+            //       unsquashedIdentity.type === "always" ? "ALWAYS" : "BY DEFAULT"
+            //     } AS IDENTITY (sequence name ${identityWithSchema}${
+            //       unsquashedIdentity.increment
+            //         ? ` INCREMENT BY ${unsquashedIdentity.increment}`
+            //         : ""
+            //     }${
+            //       unsquashedIdentity.minValue
+            //         ? ` MINVALUE ${unsquashedIdentity.minValue}`
+            //         : ""
+            //     }${
+            //       unsquashedIdentity.maxValue
+            //         ? ` MAXVALUE ${unsquashedIdentity.maxValue}`
+            //         : ""
+            //     }${
+            //       unsquashedIdentity.startWith
+            //         ? ` START WITH ${unsquashedIdentity.startWith}`
+            //         : ""
+            //     }${unsquashedIdentity.cache ? ` CACHE ${unsquashedIdentity.cache}` : ""}${
+            //       unsquashedIdentity.cycle ? " CYCLE" : ""
+            //     })`
+            //   : "";
+            statement += `\t"${column.name}" ${type}${primaryKeyStatement}${defaultStatement}${notNullStatement}`;
+            statement += i === columns.length - 1 ? "" : ",\n";
+        }
+        if (typeof compositePKs !== "undefined" && compositePKs.length > 0) {
+            statement += ",\n";
+            const compositePK = PgSquasher.unsquashPK(compositePKs[0]);
+            statement += `\tCONSTRAINT "${st.compositePkName}" PRIMARY KEY(\"${compositePK.columns.join(`","`)}\")`;
+            // statement += `\n`;
+        }
+        // if (
+        //   typeof uniqueConstraints !== "undefined" &&
+        //   uniqueConstraints.length > 0
+        // ) {
+        //   for (const uniqueConstraint of uniqueConstraints) {
+        //     statement += ",\n";
+        //     const unsquashedUnique = PgSquasher.unsquashUnique(uniqueConstraint);
+        //     statement += `\tCONSTRAINT "${unsquashedUnique.name}" UNIQUE${
+        //       unsquashedUnique.nullsNotDistinct ? " NULLS NOT DISTINCT" : ""
+        //     }(\"${unsquashedUnique.columns.join(`","`)}\")`;
+        //     // statement += `\n`;
+        //   }
+        // }
+        // if (
+        //   typeof checkConstraints !== "undefined" &&
+        //   checkConstraints.length > 0
+        // ) {
+        //   for (const checkConstraint of checkConstraints) {
+        //     statement += ",\n";
+        //     const unsquashedCheck = PgSquasher.unsquashCheck(checkConstraint);
+        //     statement += `\tCONSTRAINT "${unsquashedCheck.name}" CHECK (${unsquashedCheck.value})`;
+        //   }
+        // }
+        statement += "\n);";
+        statement += "\n";
+        return statement;
+    }
+}
+class PgCreateViewConvertor extends Convertor {
+    can(statement, dialect) {
+        return statement.type === "create_view" && dialect === "postgresql";
+    }
+    convert(st) {
+        const { definition, name: viewName, schema, with: withOption, materialized, withNoData, tablespace, using, } = st;
+        const name = schema ? `"${schema}"."${viewName}"` : `"${viewName}"`;
+        let statement = materialized
+            ? `CREATE MATERIALIZED VIEW ${name}`
+            : `CREATE VIEW ${name}`;
+        if (using)
+            statement += ` USING "${using}"`;
+        const options = [];
+        if (withOption) {
+            statement += " WITH (";
+            Object.entries(withOption).forEach(([key, value]) => {
+                if (typeof value === "undefined")
+                    return;
+                options.push(`${toSnakeCase(key)} = ${value}`);
+            });
+            statement += options.join(", ");
+            statement += ")";
+        }
+        if (tablespace)
+            statement += ` TABLESPACE ${tablespace}`;
+        statement += ` AS (${definition})`;
+        if (withNoData)
+            statement += " WITH NO DATA";
+        statement += ";";
+        return statement;
+    }
+}
+class CreateTypeEnumConvertor extends Convertor {
+    can(statement) {
+        return statement.type === "create_type_enum";
+    }
+    convert(st) {
+        const { name, values, schema } = st;
+        const enumNameWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+        let valuesStatement = "(";
+        valuesStatement += values.map((it) => `'${it}'`).join(", ");
+        valuesStatement += ")";
+        // TODO do we need this?
+        // let statement = 'DO $$ BEGIN';
+        // statement += '\n';
+        const statement = `CREATE TYPE ${enumNameWithSchema} AS ENUM${valuesStatement};`;
+        // statement += '\n';
+        // statement += 'EXCEPTION';
+        // statement += '\n';
+        // statement += ' WHEN duplicate_object THEN null;';
+        // statement += '\n';
+        // statement += 'END $$;';
+        // statement += '\n';
+        return statement;
+    }
+}
+class CreatePgIndexConvertor extends Convertor {
+    can(statement, dialect) {
+        return statement.type === "create_index_pg" && dialect === "postgresql";
+    }
+    convert(statement) {
+        const { name, columns, isUnique, concurrently, with: withMap, method, where, } = statement.data;
+        // // since postgresql 9.5
+        const indexPart = isUnique ? "UNIQUE INDEX" : "INDEX";
+        const value = columns
+            .map((it) => `${it.isExpression ? it.expression : `"${it.expression}"`}${it.opclass ? ` ${it.opclass}` : it.asc ? "" : " DESC"}${(it.asc && it.nulls && it.nulls === "last") || it.opclass
+            ? ""
+            : ` NULLS ${it.nulls.toUpperCase()}`}`)
+            .join(",");
+        const tableNameWithSchema = statement.schema
+            ? `"${statement.schema}"."${statement.tableName}"`
+            : `"${statement.tableName}"`;
+        function reverseLogic(mappedWith) {
+            let reversedString = "";
+            for (const key in mappedWith) {
+                // biome-ignore lint/suspicious/noPrototypeBuiltins: <explanation>
+                if (mappedWith.hasOwnProperty(key)) {
+                    reversedString += `${key}=${mappedWith[key]},`;
+                }
+            }
+            reversedString = reversedString.slice(0, -1);
+            return reversedString;
+        }
+        return `CREATE ${indexPart}${concurrently ? " CONCURRENTLY" : ""} IF NOT EXISTS "${name}" ON ${tableNameWithSchema} USING ${method} (${value})${Object.keys(withMap).length !== 0
+            ? ` WITH (${reverseLogic(withMap)})`
+            : ""}${where ? ` WHERE ${where}` : ""};`;
+    }
+}
+class PgCreateSchemaConvertor extends Convertor {
+    can(statement, dialect) {
+        return statement.type === "create_schema" && dialect === "postgresql";
+    }
+    convert(statement) {
+        const { name } = statement;
+        return `CREATE SCHEMA IF NOT EXISTS"${name}";\n`;
+    }
+}
+const convertors = [];
+convertors.push(new PgCreateTableConvertor());
+convertors.push(new PgCreateViewConvertor());
+convertors.push(new CreateTypeEnumConvertor());
+convertors.push(new CreatePgIndexConvertor());
+convertors.push(new PgCreateSchemaConvertor());
+const preparePgCreateTableJson = (table, json) => {
+    const { name, schema, columns, compositePrimaryKeys } = table;
+    const tableKey = `${schema || "public"}.${name}`;
+    // TODO: @AndriiSherman. We need this, will add test cases
+    const compositePkName = Object.values(compositePrimaryKeys).length > 0
+        ? json.tables[tableKey].compositePrimaryKeys[`${PgSquasher.unsquashPK(Object.values(compositePrimaryKeys)[0]).name}`].name
+        : "";
+    return {
+        type: "create_table",
+        tableName: name,
+        schema,
+        columns: Object.values(columns),
+        compositePKs: Object.values(compositePrimaryKeys),
+        compositePkName: compositePkName,
+    };
+};
+const preparePgCreateViewJson = (name, schema, definition, materialized, withNoData = false, withOption, using, tablespace) => {
+    return {
+        type: "create_view",
+        name: name,
+        schema: schema,
+        definition: definition,
+        with: withOption,
+        materialized: materialized,
+        withNoData,
+        using,
+        tablespace,
+    };
+};
+const preparePgCreateIndexesJson = (tableName, schema, indexes) => {
+    return Object.values(indexes).map((indexData) => {
+        return {
+            type: "create_index_pg",
+            tableName,
+            data: PgSquasher.unsquashIdx(indexData),
+            schema,
+        };
+    });
+};
+const prepareCreateEnumJson = (name, schema, values) => {
+    return {
+        type: "create_type_enum",
+        name: name,
+        schema: schema,
+        values,
+    };
+};
+const prepareFromExports = (exports) => {
+    const tables = [];
+    const enums = [];
+    const schemas = [];
+    const sequences = [];
+    const views = [];
+    const matViews = [];
+    const i0values = Object.values(exports);
+    i0values.forEach((t) => {
+        if (isPgEnum(t)) {
+            enums.push(t);
+            return;
+        }
+        if (is(t, PgTable)) {
+            tables.push(t);
+        }
+        if (is(t, PgSchema)) {
+            schemas.push(t);
+        }
+        if (is(t, PgView)) {
+            views.push(t);
+        }
+        if (is(t, PgMaterializedView)) {
+            matViews.push(t);
+        }
+        if (isPgSequence(t)) {
+            sequences.push(t);
+        }
+    });
+    return { tables, enums, schemas, sequences, views, matViews };
+};
+export function getColumnCasing(column, casing) {
+    if (!column.name)
+        return "";
+    return !column.keyAsName || casing === undefined
+        ? column.name
+        : casing === "camelCase"
+            ? toCamelCase(column.name)
+            : toSnakeCase(column.name);
+}
+const sqlToStr = (sql, casing) => {
+    return sql.toQuery({
+        escapeName: () => {
+            throw new Error("we don't support params for `sql` default values");
+        },
+        escapeParam: () => {
+            throw new Error("we don't support params for `sql` default values");
+        },
+        escapeString: () => {
+            throw new Error("we don't support params for `sql` default values");
+        },
+        casing: new CasingCache(casing),
+    }).sql;
+};
+function isPgArrayType(sqlType) {
+    return sqlType.match(/.*\[\d*\].*|.*\[\].*/g) !== null;
+}
+function buildArrayString(array, sqlType) {
+    sqlType = sqlType.split("[")[0];
+    const values = array
+        .map((value) => {
+        if (typeof value === "number" || typeof value === "bigint") {
+            return value.toString();
+        }
+        else if (typeof value === "boolean") {
+            return value ? "true" : "false";
+        }
+        else if (Array.isArray(value)) {
+            return buildArrayString(value, sqlType);
+        }
+        else if (value instanceof Date) {
+            if (sqlType === "date") {
+                return `"${value.toISOString().split("T")[0]}"`;
+            }
+            else if (sqlType === "timestamp") {
+                return `"${value.toISOString().replace("T", " ").slice(0, 23)}"`;
+            }
+            else {
+                return `"${value.toISOString()}"`;
+            }
+        }
+        else if (typeof value === "object") {
+            return `"${JSON.stringify(value).replaceAll('"', '\\"')}"`;
+        }
+        return `"${value}"`;
+    })
+        .join(",");
+    return `{${values}}`;
+}
+const indexName = (tableName, columns) => {
+    return `${tableName}_${columns.join("_")}_index`;
+};
+const generatePgSnapshot = (tables, views, enums, schemas, casing) => {
+    const dialect = new PgDialect({ casing });
+    const result = {};
+    const resultViews = {};
+    // This object stores unique names for indexes and will be used to detect if you have the same names for indexes
+    // within the same PostgreSQL schema
+    const indexesInSchema = {};
+    for (const table of tables) {
+        const { name: tableName, columns, indexes, schema, primaryKeys, } = getTableConfig(table);
+        const columnsObject = {};
+        const indexesObject = {};
+        const primaryKeysObject = {};
+        columns.forEach((column) => {
+            const name = getColumnCasing(column, casing);
+            const notNull = column.notNull;
+            const primaryKey = column.primary;
+            const sqlTypeLowered = column.getSQLType().toLowerCase();
+            const typeSchema = is(column, PgEnumColumn)
+                ? column.enum.schema || "public"
+                : undefined;
+            const columnToSet = {
+                name,
+                type: column.getSQLType(),
+                typeSchema: typeSchema,
+                primaryKey,
+                notNull,
+            };
+            if (column.default !== undefined) {
+                if (is(column.default, SQL)) {
+                    columnToSet.default = sqlToStr(column.default, casing);
+                }
+                else {
+                    if (typeof column.default === "string") {
+                        columnToSet.default = `'${column.default}'`;
+                    }
+                    else {
+                        if (sqlTypeLowered === "jsonb" || sqlTypeLowered === "json") {
+                            columnToSet.default = `'${JSON.stringify(column.default)}'::${sqlTypeLowered}`;
+                        }
+                        else if (column.default instanceof Date) {
+                            if (sqlTypeLowered === "date") {
+                                columnToSet.default = `'${column.default.toISOString().split("T")[0]}'`;
+                            }
+                            else if (sqlTypeLowered === "timestamp") {
+                                columnToSet.default = `'${column.default.toISOString().replace("T", " ").slice(0, 23)}'`;
+                            }
+                            else {
+                                columnToSet.default = `'${column.default.toISOString()}'`;
+                            }
+                        }
+                        else if (isPgArrayType(sqlTypeLowered) &&
+                            Array.isArray(column.default)) {
+                            columnToSet.default = `'${buildArrayString(column.default, sqlTypeLowered)}'`;
+                        }
+                        else {
+                            // Should do for all types
+                            // columnToSet.default = `'${column.default}'::${sqlTypeLowered}`;
+                            columnToSet.default = column.default;
+                        }
+                    }
+                }
+            }
+            columnsObject[name] = columnToSet;
+        });
+        primaryKeys.map((pk) => {
+            const originalColumnNames = pk.columns.map((c) => c.name);
+            const columnNames = pk.columns.map((c) => getColumnCasing(c, casing));
+            let name = pk.getName();
+            if (casing !== undefined) {
+                for (let i = 0; i < originalColumnNames.length; i++) {
+                    name = name.replace(originalColumnNames[i], columnNames[i]);
+                }
+            }
+            primaryKeysObject[name] = {
+                name,
+                columns: columnNames,
+            };
+        });
+        indexes.forEach((value) => {
+            const columns = value.config.columns;
+            const indexColumnNames = [];
+            columns.forEach((it) => {
+                const name = getColumnCasing(it, casing);
+                indexColumnNames.push(name);
+            });
+            const name = value.config.name
+                ? value.config.name
+                : indexName(tableName, indexColumnNames);
+            const indexColumns = columns.map((it) => {
+                if (is(it, SQL)) {
+                    return {
+                        expression: dialect.sqlToQuery(it, "indexes").sql,
+                        asc: true,
+                        isExpression: true,
+                        nulls: "last",
+                    };
+                }
+                else {
+                    it = it;
+                    return {
+                        expression: getColumnCasing(it, casing),
+                        isExpression: false,
+                        // @ts-ignore
+                        asc: it.indexConfig?.order === "asc",
+                        // @ts-ignore
+                        nulls: it.indexConfig?.nulls
+                            ? // @ts-ignore
+                                it.indexConfig?.nulls
+                            : // @ts-ignore
+                                it.indexConfig?.order === "desc"
+                                    ? "first"
+                                    : "last",
+                        // @ts-ignore
+                        opclass: it.indexConfig?.opClass,
+                    };
+                }
+            });
+            // check for index names duplicates
+            if (typeof indexesInSchema[schema ?? "public"] !== "undefined") {
+                indexesInSchema[schema ?? "public"].push(name);
+            }
+            else {
+                indexesInSchema[schema ?? "public"] = [name];
+            }
+            indexesObject[name] = {
+                name,
+                columns: indexColumns,
+                isUnique: value.config.unique ?? false,
+                where: value.config.where
+                    ? dialect.sqlToQuery(value.config.where).sql
+                    : undefined,
+                concurrently: value.config.concurrently ?? false,
+                method: value.config.method ?? "btree",
+                with: value.config.with ?? {},
+            };
+        });
+        const tableKey = `${schema ?? "public"}.${tableName}`;
+        result[tableKey] = {
+            name: tableName,
+            schema: schema ?? "",
+            columns: columnsObject,
+            indexes: indexesObject,
+            compositePrimaryKeys: primaryKeysObject,
+        };
+    }
+    const combinedViews = [...views];
+    for (const view of combinedViews) {
+        // @ts-ignore
+        // biome-ignore lint/suspicious/noImplicitAnyLet: <explanation>
+        // biome-ignore lint/style/useConst: <explanation>
+        let viewName;
+        // @ts-ignore
+        // biome-ignore lint/suspicious/noImplicitAnyLet: <explanation>
+        // biome-ignore lint/style/useConst: <explanation>
+        let schema;
+        // @ts-ignore
+        // biome-ignore lint/suspicious/noImplicitAnyLet: <explanation>
+        // biome-ignore lint/style/useConst: <explanation>
+        let query;
+        // @ts-ignore
+        // biome-ignore lint/suspicious/noImplicitAnyLet: <explanation>
+        // biome-ignore lint/style/useConst: <explanation>
+        let selectedFields;
+        // @ts-ignore
+        // biome-ignore lint/suspicious/noImplicitAnyLet: <explanation>
+        // biome-ignore lint/style/useConst: <explanation>
+        let isExisting;
+        // @ts-ignore
+        // biome-ignore lint/suspicious/noImplicitAnyLet: <explanation>
+        // biome-ignore lint/style/useConst: <explanation>
+        let withOption;
+        // @ts-ignore
+        // biome-ignore lint/suspicious/noImplicitAnyLet: <explanation>
+        // biome-ignore lint/style/useConst: <explanation>
+        let tablespace;
+        // @ts-ignore
+        // biome-ignore lint/suspicious/noImplicitAnyLet: <explanation>
+        // biome-ignore lint/style/useConst: <explanation>
+        let using;
+        // @ts-ignore
+        // biome-ignore lint/suspicious/noImplicitAnyLet: <explanation>
+        // biome-ignore lint/style/useConst: <explanation>
+        let withNoData;
+        const materialized = false;
+        // if (is(view, PgView)) {
+        ({
+            name: viewName,
+            schema,
+            query,
+            selectedFields,
+            isExisting,
+            with: withOption,
+        } = getViewConfig(view));
+        // } else {
+        // 	({ name: viewName, schema, query, selectedFields, isExisting, with: withOption, tablespace, using, withNoData } =
+        // 		getMaterializedViewConfig(view));
+        // 	materialized = true;
+        // }
+        const viewSchema = schema ?? "public";
+        const viewKey = `${viewSchema}.${viewName}`;
+        const columnsObject = {};
+        // const uniqueConstraintObject: Record<string, UniqueConstraint> = {};
+        // const existingView = resultViews[viewKey];
+        // if (typeof existingView !== 'undefined') {
+        // 	console.log(
+        // 		`\n${
+        // 			withStyle.errorWarning(
+        // 				`We\'ve found duplicated view name across ${
+        // 					chalk.underline.blue(schema ?? 'public')
+        // 				} schema. Please rename your view`,
+        // 			)
+        // 		}`,
+        // 	);
+        // 	process.exit(1);
+        // }
+        for (const key in selectedFields) {
+            if (is(selectedFields[key], PgColumn)) {
+                const column = selectedFields[key];
+                const notNull = column.notNull;
+                const primaryKey = column.primary;
+                const sqlTypeLowered = column.getSQLType().toLowerCase();
+                const typeSchema = is(column, PgEnumColumn)
+                    ? column.enum.schema || "public"
+                    : undefined;
+                // const generated = column.generated;
+                // const identity = column.generatedIdentity;
+                // const increment = stringFromIdentityProperty(identity?.sequenceOptions?.increment) ?? '1';
+                // const minValue = stringFromIdentityProperty(identity?.sequenceOptions?.minValue)
+                // 	?? (Number.parseFloat(increment) < 0 ? minRangeForIdentityBasedOn(column.columnType) : '1');
+                // const maxValue = stringFromIdentityProperty(identity?.sequenceOptions?.maxValue)
+                // 	?? (Number.parseFloat(increment) < 0 ? '-1' : maxRangeForIdentityBasedOn(column.getSQLType()));
+                // const startWith = stringFromIdentityProperty(identity?.sequenceOptions?.startWith)
+                // 	?? (Number.parseFloat(increment) < 0 ? maxValue : minValue);
+                // const cache = stringFromIdentityProperty(identity?.sequenceOptions?.cache) ?? '1';
+                const columnToSet = {
+                    name: column.name,
+                    type: column.getSQLType(),
+                    typeSchema: typeSchema,
+                    primaryKey,
+                    notNull,
+                    // generated: generated
+                    // 	? {
+                    // 		as: is(generated.as, SQL)
+                    // 			? dialect.sqlToQuery(generated.as as SQL).sql
+                    // 			: typeof generated.as === 'function'
+                    // 			? dialect.sqlToQuery(generated.as() as SQL).sql
+                    // 			: (generated.as as any),
+                    // 		type: 'stored',
+                    // 	}
+                    // 	: undefined,
+                    // identity: identity
+                    // 	? {
+                    // 		type: identity.type,
+                    // 		name: identity.sequenceName ?? `${viewName}_${column.name}_seq`,
+                    // 		schema: schema ?? 'public',
+                    // 		increment,
+                    // 		startWith,
+                    // 		minValue,
+                    // 		maxValue,
+                    // 		cache,
+                    // 		cycle: identity?.sequenceOptions?.cycle ?? false,
+                    // 	}
+                    // 	: undefined,
+                };
+                // if (column.isUnique) {
+                // 	// const existingUnique = uniqueConstraintObject[column.uniqueName!];
+                // 	// if (typeof existingUnique !== 'undefined') {
+                // 	// 	console.log(
+                // 	// 		`\n${
+                // 	// 			withStyle.errorWarning(
+                // 	// 				`We\'ve found duplicated unique constraint names in ${chalk.underline.blue(viewName)} table.
+                //   // The unique constraint ${chalk.underline.blue(column.uniqueName)} on the ${
+                // 	// 					chalk.underline.blue(
+                // 	// 						column.name,
+                // 	// 					)
+                // 	// 				} column is conflicting with a unique constraint name already defined for ${
+                // 	// 					chalk.underline.blue(existingUnique.columns.join(','))
+                // 	// 				} columns\n`,
+                // 	// 			)
+                // 	// 		}`,
+                // 	// 	);
+                // 	// 	process.exit(1);
+                // 	// }
+                // 	uniqueConstraintObject[column.uniqueName!] = {
+                // 		name: column.uniqueName!,
+                // 		nullsNotDistinct: column.uniqueType === 'not distinct',
+                // 		columns: [columnToSet.name],
+                // 	};
+                // }
+                if (column.default !== undefined) {
+                    if (is(column.default, SQL)) {
+                        columnToSet.default = sqlToStr(column.default, casing);
+                    }
+                    else {
+                        if (typeof column.default === "string") {
+                            columnToSet.default = `'${column.default}'`;
+                        }
+                        else {
+                            if (sqlTypeLowered === "jsonb" || sqlTypeLowered === "json") {
+                                columnToSet.default = `'${JSON.stringify(column.default)}'::${sqlTypeLowered}`;
+                            }
+                            else if (column.default instanceof Date) {
+                                if (sqlTypeLowered === "date") {
+                                    columnToSet.default = `'${column.default.toISOString().split("T")[0]}'`;
+                                }
+                                else if (sqlTypeLowered === "timestamp") {
+                                    columnToSet.default = `'${column.default.toISOString().replace("T", " ").slice(0, 23)}'`;
+                                }
+                                else {
+                                    columnToSet.default = `'${column.default.toISOString()}'`;
+                                }
+                            }
+                            else if (isPgArrayType(sqlTypeLowered) &&
+                                Array.isArray(column.default)) {
+                                columnToSet.default = `'${buildArrayString(column.default, sqlTypeLowered)}'`;
+                            }
+                            else {
+                                // Should do for all types
+                                // columnToSet.default = `'${column.default}'::${sqlTypeLowered}`;
+                                columnToSet.default = column.default;
+                            }
+                        }
+                    }
+                }
+                columnsObject[column.name] = columnToSet;
+            }
+        }
+        resultViews[viewKey] = {
+            columns: columnsObject,
+            definition: isExisting ? undefined : dialect.sqlToQuery(query).sql,
+            name: viewName,
+            schema: viewSchema,
+            isExisting,
+            with: withOption,
+            withNoData,
+            materialized,
+            tablespace,
+            using,
+        };
+    }
+    const enumsToReturn = enums.reduce((map, obj) => {
+        const enumSchema = obj.schema || "public";
+        const key = `${enumSchema}.${obj.enumName}`;
+        map[key] = {
+            name: obj.enumName,
+            schema: enumSchema,
+            values: obj.enumValues,
+        };
+        return map;
+    }, {});
+    const schemasObject = Object.fromEntries(schemas
+        .filter((it) => {
+        return it.schemaName !== "public";
+    })
+        .map((it) => [it.schemaName, it.schemaName]));
+    return {
+        version: "7",
+        dialect: "postgresql",
+        tables: result,
+        enums: enumsToReturn,
+        schemas: schemasObject,
+        views: resultViews,
+    };
+};
+const mapValues = (obj, map) => {
+    const result = Object.keys(obj).reduce((result, key) => {
+        result[key] = map(obj[key]);
+        return result;
+    }, {});
+    return result;
+};
+const squashPgScheme = (json) => {
+    const mappedTables = Object.fromEntries(Object.entries(json.tables).map((it) => {
+        const squashedIndexes = mapValues(it[1].indexes, (index) => {
+            return PgSquasher.squashIdx(index);
+        });
+        const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
+            return PgSquasher.squashPK(pk);
+        });
+        const mappedColumns = Object.fromEntries(Object.entries(it[1].columns).map((it) => {
+            return [
+                it[0],
+                {
+                    ...it[1],
+                    identity: undefined,
+                },
+            ];
+        }));
+        return [
+            it[0],
+            {
+                name: it[1].name,
+                schema: it[1].schema,
+                columns: mappedColumns,
+                indexes: squashedIndexes,
+                compositePrimaryKeys: squashedPKs,
+            },
+        ];
+    }));
+    return {
+        version: "7",
+        dialect: json.dialect,
+        tables: mappedTables,
+        enums: json.enums,
+        schemas: json.schemas,
+        views: json.views,
+    };
+};
+//# sourceMappingURL=index.js.map