@casekit/orm 0.0.1-alpha.9 → 0.0.1-release-candidate.2

package/src/pull/introspect/getPrimaryKeys.ts

@@ -1,26 +0,0 @@
-import { groupBy, mapValues, sortBy } from "lodash-es";
-import pg from "pg";
-
-import { sql } from "../../sql";
-import { PrimaryKey } from "../types/PrimaryKey";
-
-export const getPrimaryKeys = async (
-    client: pg.Client,
-    schema: string,
-): Promise<Record<string, string[]>> => {
-    const results = await client.query<PrimaryKey>(
-        sql`select
-             cc.table_name as table,
-             cc.constraint_name as name,
-             cc.column_name as column,
-             cc.ordinal_position as ordinal
-             from information_schema.table_constraints c
-             join information_schema.key_column_usage cc on c.constraint_name = cc.constraint_name and c.constraint_schema = cc.constraint_schema and c.table_name = cc.table_name
-             where c.constraint_type = 'PRIMARY KEY'
-             and c.constraint_schema = ${schema}`,
-    );
-
-    return mapValues(groupBy(results.rows, "table"), (columns) =>
-        sortBy(columns, "ordinal").map((c) => c.column),
-    );
-};

package/src/pull/introspect/getTables.ts

@@ -1,51 +0,0 @@
-import { groupBy, mapValues, sortBy } from "lodash-es";
-import pg from "pg";
-
-import { sql } from "../../sql";
-import { ColumnMeta } from "../types/ColumnMeta";
-
-export const getTables = async (client: pg.Client, schema: string) => {
-    const results = await client.query<ColumnMeta>(
-        sql`WITH array_columns AS (
-            	SELECT
-            		ns.nspname AS schema,
-            		(c.oid::regclass)::text AS table,
-            		attname AS column,
-            		attndims AS cardinality
-            	FROM
-            		pg_class c
-            		JOIN pg_attribute a ON c.oid = attrelid
-            		JOIN pg_type t ON t.oid = atttypid
-            		JOIN pg_catalog.pg_namespace AS ns ON c.relnamespace = ns.oid
-            	WHERE
-            		a.attnum > 0
-            )
-            SELECT
-            	c.table_name AS table,
-            	c.column_name AS name,
-            	c.ordinal_position AS ordinal,
-            	c.column_default AS default,
-            	CASE WHEN c.is_nullable = 'YES' THEN
-            		TRUE
-            	ELSE
-            		FALSE
-            	END AS nullable,
-            	c.data_type AS type,
-            	e.data_type AS elementtype,
-            	coalesce(arr.cardinality, 0) AS cardinality
-            FROM
-            	information_schema.columns c
-            	LEFT JOIN information_schema.element_types e ON c.table_catalog = e.object_catalog
-            		AND c.table_schema = e.object_schema
-            		AND e.collection_type_identifier = c.dtd_identifier
-            		AND c.data_type = 'ARRAY'
-            	LEFT JOIN array_columns arr ON arr.schema = c.table_schema
-            		AND arr.table = c.table_name
-            		AND arr.column = c.column_name
-            WHERE
-            	c.table_schema = ${schema}`,
-    );
-    return mapValues(groupBy(results.rows, "table"), (columns) =>
-        sortBy(columns, "ordinal"),
-    );
-};

package/src/pull/introspect/getUniqueConstraints.ts

@@ -1,39 +0,0 @@
-import { groupBy } from "lodash-es";
-import pg from "pg";
-
-import { sql } from "../../sql";
-import { parseCreateUniqueIndexStatement } from "../parse/parseCreateUniqueIndexStatement";
-import { UniqueConstraint } from "../types/UniqueConstraint";
-
-/**
- * Doing this with string manipulation in this way feels pretty hacky,
- * so it would be great if we can find a better way to do it.
- * In particular, this is likely to break if column names have parentheses in them.
- * Couldn't find a way to easily get the columns and conditions from the
- * information_schema * or pg_catalog tables though.
- */
-export const getUniqueConstraints = async (
-    client: pg.Client,
-    schema: string,
-): Promise<Record<string, UniqueConstraint[]>> => {
-    const results = await client.query<{
-        table: string;
-        definition: string;
-        name: string;
-    }>(
-        sql`select i.tablename as table, i.indexdef as definition, i.indexname as name
-            from pg_indexes i
-            left join pg_constraint c on i.indexname = c.conname and c.contype in ('p', 'x')
-            where schemaname = ${schema}
-            and c.conname is null
-            and indexdef like 'CREATE UNIQUE INDEX%';
-        `,
-    );
-
-    const parsed = results.rows.map((result) => ({
-        ...result,
-        ...parseCreateUniqueIndexStatement(result.definition),
-    }));
-
-    return groupBy(parsed, "table");
-};

package/src/pull/parse/parseCreateUniqueIndexStatement.test.ts

@@ -1,14 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import { parseCreateUniqueIndexStatement } from "./parseCreateUniqueIndexStatement";
-
-describe("parseCreateUniqueIndexStatement", () => {
-    test("it extracts out the index's columns and a condition if present", () => {
-        const parsed = parseCreateUniqueIndexStatement(
-            "CREATE UNIQUE INDEX field_value_field_id_ordinal ON casekit.field_value USING btree (field_id, ordinal) WHERE (deleted_at IS NULL)",
-        );
-
-        expect(parsed.columns).toEqual(["field_id", "ordinal"]);
-        expect(parsed.where).toEqual("deleted_at IS NULL");
-    });
-});

package/src/pull/parse/parseCreateUniqueIndexStatement.ts

@@ -1,19 +0,0 @@
-export const parseCreateUniqueIndexStatement = (
-    command: string,
-): { columns: string[]; where?: string; nullsNotDistinct: boolean } => {
-    const columnsMatch = command.match(/ON[^(]*\(([^)]*)\)/);
-    if (!columnsMatch || !columnsMatch[1])
-        throw new Error("Unable to parse unique index statement: " + command);
-
-    const columns = columnsMatch[1].split(", ");
-
-    const whereMatch = command.match(/WHERE[^(]*\(([^)]*)\)/);
-
-    const nullsNotDistinct = !!command.match(/NULLS NOT DISTINCT/);
-
-    return {
-        columns,
-        where: whereMatch ? whereMatch[1] : undefined,
-        nullsNotDistinct,
-    };
-};

package/src/pull/pull.ts

@@ -1,78 +0,0 @@
-import fs from "fs";
-import { camelCase } from "lodash-es";
-import path from "path";
-import pg from "pg";
-
-import { getForeignKeys } from "./introspect/getForeignKeys";
-import { getPrimaryKeys } from "./introspect/getPrimaryKeys";
-import { getTables } from "./introspect/getTables";
-import { getUniqueConstraints } from "./introspect/getUniqueConstraints";
-import { renderModel } from "./render/renderModel";
-import { renderModelsIndex } from "./render/renderModelsIndex";
-import { renderRelations } from "./render/renderRelations";
-import { renderRelationsIndex } from "./render/renderRelationsIndex";
-import { format } from "./util/format";
-
-export const pull = async (
-    client: pg.Client,
-    opts: { schema: string; outDir: string },
-) => {
-    const tables = await getTables(client, opts.schema);
-    const primaryKeys = await getPrimaryKeys(client, opts.schema);
-    const uniqueConstraints = await getUniqueConstraints(client, opts.schema);
-    const foreignKeys = await getForeignKeys(client, opts.schema);
-
-    fs.mkdirSync(path.resolve(opts.outDir, "models"), { recursive: true });
-
-    for (const [table, columns] of Object.entries(tables)) {
-        fs.writeFileSync(
-            path.resolve(opts.outDir, "models", `${camelCase(table)}.model.ts`),
-            await renderModel({
-                table,
-                columns,
-                primaryKey: primaryKeys[table] ?? [],
-                uniqueConstraints: uniqueConstraints[table] ?? [],
-                foreignKeys: foreignKeys[table] ?? [],
-            }),
-            { encoding: "utf-8" },
-        );
-    }
-
-    fs.writeFileSync(
-        path.resolve(opts.outDir, "models.ts"),
-        await renderModelsIndex(Object.keys(tables)),
-        { encoding: "utf-8" },
-    );
-
-    for (const table of Object.keys(tables)) {
-        fs.writeFileSync(
-            path.resolve(
-                opts.outDir,
-                "models",
-                `${camelCase(table)}.relations.ts`,
-            ),
-            await renderRelations({
-                table,
-                foreignKeys: foreignKeys,
-            }),
-            { encoding: "utf-8" },
-        );
-    }
-
-    fs.writeFileSync(
-        path.resolve(opts.outDir, "relations.ts"),
-        await renderRelationsIndex(Object.keys(tables)),
-        { encoding: "utf-8" },
-    );
-
-    if (!fs.existsSync(path.resolve(opts.outDir, "index.ts"))) {
-        fs.writeFileSync(
-            path.resolve(opts.outDir, "index.ts"),
-            await format(`
-            export { models, type Models } from "./models";
-            export { relations, type Relations } from "./relations";
-        `),
-            { encoding: "utf-8" },
-        );
-    }
-};

package/src/pull/render/renderModel.test.ts

@@ -1,144 +0,0 @@
-import { unindent } from "@casekit/unindent";
-
-import { describe, expect, test } from "vitest";
-
-import { renderModel } from "./renderModel";
-
-describe("renderModel", () => {
-    test("it renders a valid model definition given introspection results", async () => {
-        expect(
-            await renderModel({
-                table: "my_table",
-                columns: [
-                    {
-                        name: "id",
-                        type: "uuid",
-                        default: "uuid_generate_v4()",
-                        cardinality: 0,
-                        elementtype: null,
-                        table: "my_table",
-                        ordinal: 0,
-                        nullable: false,
-                    },
-                    {
-                        name: "name",
-                        type: "text",
-                        default: null,
-                        cardinality: 0,
-                        elementtype: null,
-                        table: "my_table",
-                        ordinal: 1,
-                        nullable: true,
-                    },
-                ],
-                uniqueConstraints: [
-                    {
-                        name: "my_table_name_unique",
-                        table: "my_table",
-                        definition:
-                            "CREATE UNIQUE INDEX ON my_table USING btree (name)",
-                        columns: ["name"],
-                        where: undefined,
-                    },
-                ],
-                foreignKeys: [],
-                primaryKey: ["id"],
-            }),
-        ).toEqual(
-            unindent`
-            import { type ModelDefinition, type ModelType, sql } from "@casekit/orm";
-
-            export const myTable = {
-                table: "my_table",
-                columns: {
-                    id: {
-                        name: "id",
-                        type: "uuid",
-                        primaryKey: true,
-                        default: sql\`uuid_generate_v4()\`,
-                    },
-                    name: { name: "name", type: "text", unique: true, nullable: true },
-                },
-            } as const satisfies ModelDefinition;
-
-            export type MyTable = ModelType<typeof myTable>;
-        ` + "\n",
-        );
-    });
-    test("it renders a valid model definition given introspection results with a column-local unique constraint", async () => {
-        expect(
-            await renderModel({
-                table: "my_table",
-                columns: [
-                    {
-                        name: "id",
-                        type: "uuid",
-                        default: "uuid_generate_v4()",
-                        cardinality: 0,
-                        elementtype: null,
-                        table: "my_table",
-                        ordinal: 0,
-                        nullable: false,
-                    },
-                    {
-                        name: "name",
-                        type: "text",
-                        default: null,
-                        cardinality: 0,
-                        elementtype: null,
-                        table: "my_table",
-                        ordinal: 1,
-                        nullable: true,
-                    },
-                    {
-                        name: "deleted_at",
-                        type: "timestamp",
-                        default: null,
-                        cardinality: 0,
-                        elementtype: null,
-                        table: "my_table",
-                        ordinal: 2,
-                        nullable: true,
-                    },
-                ],
-                uniqueConstraints: [
-                    {
-                        name: "my_table_name_unique",
-                        table: "my_table",
-                        definition:
-                            "CREATE UNIQUE INDEX ON my_table USING btree (name)",
-                        columns: ["name"],
-                        where: "deleted_at IS NULL",
-                    },
-                ],
-                primaryKey: ["id"],
-                foreignKeys: [],
-            }),
-        ).toEqual(
-            unindent`
-            import { type ModelDefinition, type ModelType, sql } from "@casekit/orm";
-
-            export const myTable = {
-                table: "my_table",
-                columns: {
-                    id: {
-                        name: "id",
-                        type: "uuid",
-                        primaryKey: true,
-                        default: sql\`uuid_generate_v4()\`,
-                    },
-                    name: {
-                        name: "name",
-                        type: "text",
-                        unique: { where: sql\`deleted_at IS NULL\` },
-                        nullable: true,
-                    },
-                    deletedAt: { name: "deleted_at", type: "timestamp", nullable: true },
-                },
-            } as const satisfies ModelDefinition;
-
-            export type MyTable = ModelType<typeof myTable>;
-        ` + "\n",
-        );
-    });
-});

package/src/pull/render/renderModel.ts

@@ -1,141 +0,0 @@
-import { camelCase, identity, times, upperFirst } from "lodash-es";
-
-import { ColumnMeta } from "../types/ColumnMeta";
-import { ForeignKey } from "../types/ForeignKey";
-import { UniqueConstraint } from "../types/UniqueConstraint";
-import { format } from "../util/format";
-import { quote } from "../util/quote";
-
-type Definition = {
-    table: string;
-    columns: ColumnMeta[];
-    primaryKey: string[];
-    uniqueConstraints: UniqueConstraint[];
-    foreignKeys: ForeignKey[];
-};
-
-const renderDefault = (d: string) => {
-    return d.match(/^\d+$/)
-        ? `${d}`
-        : d.match(/::text$/)
-          ? d.replace(/::text$/, "")
-          : ["true", "false"].includes(d)
-            ? d
-            : `sql\`${d}\``;
-};
-
-const renderType = (column: ColumnMeta) => {
-    if (column.type === "ARRAY") {
-        return (
-            column.elementtype +
-            times(column.cardinality)
-                .map(() => "[]")
-                .join("")
-        );
-    } else {
-        return column.type;
-    }
-};
-
-export const renderColumn = (def: Definition) => (column: ColumnMeta) => {
-    const primaryKey =
-        def.primaryKey.length === 1 && def.primaryKey[0] === column.name;
-
-    const unique = def.uniqueConstraints.find(
-        (uc) => uc.columns.length === 1 && uc.columns[0] === column.name,
-    );
-
-    const references = def.foreignKeys.find(
-        (fk) =>
-            fk.columnsFrom.length === 1 && fk.columnsFrom[0] === column.name,
-    );
-
-    const definition = [
-        `name: "${column.name}"`,
-        `type: "${renderType(column)}"`,
-        primaryKey ? "primaryKey: true" : null,
-        unique ? `unique: ${renderColumnUniqueConstraint(unique)}` : null,
-        column.nullable ? "nullable: true" : null,
-        column.default ? `default: ${renderDefault(column.default)}` : null,
-        references
-            ? `references: { table: ${quote(references.tableTo)}, column: ${quote(references.columnsTo[0])} }`
-            : null,
-    ]
-        .filter(identity)
-        .join(", ");
-
-    return `"${camelCase(column.name)}": { ${definition} }`;
-};
-
-export const renderColumnUniqueConstraint = (constraint: UniqueConstraint) => {
-    if (constraint.nullsNotDistinct || constraint.where) {
-        return `{${constraint.nullsNotDistinct ? " nullsNotDistinct: true," : ""}${constraint.where ? ` where: sql\`${constraint.where}\`}` : ""}`;
-    } else {
-        return "true";
-    }
-};
-
-export const renderUniqueConstraint = (constraint: UniqueConstraint) => {
-    return `{ columns: [${constraint.columns.map(quote).join(", ")}], ${constraint.where ? `where: sql\`${constraint.where}\`,` : ""} }`;
-};
-
-export const renderUniqueConstraints = (constraints: UniqueConstraint[]) => {
-    return `uniqueConstraints: [ ${constraints.map(renderUniqueConstraint).join(", ")} ]`;
-};
-
-export const renderForeignKey = (constraint: ForeignKey) => {
-    return `{
-        columns: [${constraint.columnsFrom.map(quote).join(", ")}],
-        references: {
-             table: ${quote(constraint.tableTo)},
-             columns: [${constraint.columnsTo.map(quote).join(", ")}]
-        }
-    }`;
-};
-
-export const renderForeignKeys = (constraints: ForeignKey[]) => {
-    return `foreignKeys: [ ${constraints.map(renderForeignKey).join(", ")} ]`;
-};
-
-export const renderModel = async (def: Definition) => {
-    const imports = ["type ModelDefinition", "type ModelType"];
-    if (def.columns.find((c) => c.default !== null)) {
-        imports.push("sql");
-    }
-
-    const lines: string[] = [];
-
-    lines.push(
-        `columns: { ${def.columns.map(renderColumn(def)).join(",\n")} }`,
-    );
-
-    if (def.primaryKey.length > 1) {
-        lines.push(`primaryKey: [${def.primaryKey.map(quote).join(", ")}]`);
-    }
-
-    const multiColumnUniqueConstraints = def.uniqueConstraints.filter(
-        (uc) => uc.columns.length > 1,
-    );
-
-    if (multiColumnUniqueConstraints.length > 0) {
-        lines.push(renderUniqueConstraints(multiColumnUniqueConstraints));
-    }
-
-    const multiColumnForeignKeys = def.foreignKeys.filter(
-        (fk) => fk.columnsFrom.length > 1,
-    );
-
-    if (multiColumnForeignKeys.length > 0) {
-        lines.push(renderForeignKeys(multiColumnForeignKeys));
-    }
-
-    return await format(`
-        import { ${imports.join(", ")} } from "@casekit/orm";
-
-        export const ${camelCase(def.table)} = {
-            table: "${def.table}",
-            ${lines.join(",\n")}
-        } as const satisfies ModelDefinition;
-        
-        export type ${upperFirst(camelCase(def.table))} = ModelType<typeof ${camelCase(def.table)}>;`);
-};

package/src/pull/render/renderModelsIndex.ts

@@ -1,24 +0,0 @@
-import { camelCase } from "lodash-es";
-
-import { format } from "../util/format";
-
-export const renderModelsIndex = async (tableNames: string[]) => {
-    const names = tableNames.map((t) => camelCase(t));
-
-    const imports = names.map(
-        (name) => `import { ${name} } from "./models/${name}.model";`,
-    );
-    const exports = names.map((name) => `${name},`);
-
-    return await format(
-        `
-            ${imports.join("\n")}
-
-            export const models = {
-                ${exports.join("\n")}
-            };
-
-            export type Models = typeof models;
-            `,
-    );
-};

package/src/pull/render/renderRelations.ts

@@ -1,77 +0,0 @@
-import { camelCase, upperFirst } from "lodash-es";
-import pluralize from "pluralize";
-
-import { ForeignKey } from "../types/ForeignKey";
-import { format } from "../util/format";
-import { unquote } from "../util/unquote";
-
-type Definition = {
-    table: string;
-    foreignKeys: Record<string, ForeignKey[]>;
-};
-
-const guessManyToOneRelationName = (fk: ForeignKey) => {
-    if (fk.columnsFrom.length > 1) {
-        return camelCase(fk.columnsFrom.join("_"));
-    } else {
-        return camelCase(fk.columnsFrom[0]).replace(/Id$/, "");
-    }
-};
-
-const guessOneToManyRelationName = (fk: ForeignKey) => {
-    if (fk.columnsFrom.length > 1) {
-        return camelCase(fk.columnsFrom.join("_") + "_" + fk.tableFrom);
-    } else {
-        const foreignName = camelCase(fk.columnsFrom[0]).replace(/Id$/, "");
-        if (foreignName === camelCase(fk.tableTo)) {
-            return camelCase(pluralize(fk.tableFrom));
-        } else {
-            return camelCase(
-                upperFirst(camelCase(fk.columnsFrom[0]).replace(/Id$/, "")) +
-                    " " +
-                    pluralize(fk.tableFrom),
-            );
-        }
-    }
-};
-
-export const renderRelations = async (def: Definition) => {
-    const manyToOne = (def.foreignKeys[def.table] ?? []).map(
-        (fk) =>
-            `${guessManyToOneRelationName(fk)}:` +
-            JSON.stringify({
-                model: camelCase(fk.tableTo),
-                type: "N:1",
-                foreignKey:
-                    fk.columnsFrom.length === 1
-                        ? camelCase(fk.columnsFrom[0])
-                        : fk.columnsFrom.map(camelCase),
-            }),
-    );
-
-    const oneToMany = Object.entries(def.foreignKeys).flatMap(([table, fks]) =>
-        fks
-            .filter((fk) => unquote(fk.tableTo) === unquote(def.table))
-            .map(
-                (fk) =>
-                    `${guessOneToManyRelationName(fk)}:` +
-                    JSON.stringify({
-                        model: camelCase(table),
-                        type: "1:N",
-                        foreignKey:
-                            fk.columnsFrom.length === 1
-                                ? camelCase(fk.columnsFrom[0])
-                                : fk.columnsFrom.map(camelCase),
-                    }),
-            ),
-    );
-
-    return await format(`
-        import { RelationsDefinition } from "@casekit/orm";
-        import { type Models } from "../models";
-
-        export const ${camelCase(def.table)} = {
-            ${[...manyToOne, ...oneToMany].map((rel) => rel).join(",\n")}
-        } as const satisfies RelationsDefinition<Models, "${camelCase(def.table)}">;
-        `);
-};

package/src/pull/render/renderRelationsIndex.ts

@@ -1,24 +0,0 @@
-import { camelCase } from "lodash-es";
-
-import { format } from "../util/format";
-
-export const renderRelationsIndex = async (tableNames: string[]) => {
-    const names = tableNames.map((t) => camelCase(t));
-
-    const imports = names.map(
-        (name) => `import { ${name} } from "./models/${name}.relations";`,
-    );
-    const exports = names.map((name) => `${name},`);
-
-    return await format(
-        `
-            ${imports.join("\n")}
-
-            export const relations = {
-                ${exports.join("\n")}
-            };
-
-            export type Relations = typeof relations;
-            `,
-    );
-};

package/src/pull/types/ColumnMeta.ts

@@ -1,10 +0,0 @@
-export type ColumnMeta = {
-    table: string;
-    name: string;
-    ordinal: number;
-    default: string | null;
-    nullable: boolean;
-    type: string;
-    elementtype: string | null;
-    cardinality: number;
-};

package/src/pull/types/ForeignKey.ts

@@ -1,6 +0,0 @@
-export type ForeignKey = {
-    tableFrom: string;
-    columnsFrom: string[];
-    tableTo: string;
-    columnsTo: string[];
-};

package/src/pull/types/PrimaryKey.ts

@@ -1,6 +0,0 @@
-export type PrimaryKey = {
-    table: string;
-    column: string;
-    name: string;
-    ordinal: number;
-};

package/src/pull/types/UniqueConstraint.ts

@@ -1,8 +0,0 @@
-export type UniqueConstraint = {
-    table: string;
-    definition: string;
-    name: string;
-    columns: string[];
-    where?: string;
-    nullsNotDistinct?: boolean;
-};