@casekit/orm 0.0.1-alpha.0

package/src/pull/pull.ts

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,144 @@
+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

@@ -0,0 +1,141 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,77 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,10 @@
+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

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

package/src/pull/types/PrimaryKey.ts

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

package/src/pull/types/UniqueConstraint.ts

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

package/src/pull/util/format.ts

@@ -0,0 +1,17 @@
+import prettier from "prettier";
+
+export const format = async (source: string) => {
+    try {
+        return await prettier.format(source, {
+            parser: "typescript",
+            printWidth: 80,
+            tabWidth: 4,
+            trailingComma: "all",
+            singleQuote: false,
+            semi: true,
+        });
+    } catch (e) {
+        console.error(e);
+        return source;
+    }
+};

package/src/pull/util/quote.ts

@@ -0,0 +1,7 @@
+import { unquote } from "./unquote";
+
+export const quote = (s: string) => {
+    // we unquote the string first to avoid
+    // double quoting
+    return JSON.stringify(unquote(s));
+};

package/src/pull/util/unquote.ts

@@ -0,0 +1,9 @@
+export const unquote = (s: string) => {
+    // if we're given an quoted string,
+    // strip the quotes
+    if (s.startsWith('"') && s.endsWith('"')) {
+        return s.substring(1, s.length - 1);
+    } else {
+        return s;
+    }
+};

package/src/queries/clauses/IncludeClause.ts

@@ -0,0 +1,23 @@
+import { ModelName } from "../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../schema/types/loose/LooseModelDefinitions";
+import { LooseRelationsDefinitions } from "../../schema/types/loose/LooseRelationsDefinitions";
+import { FindManyParams } from "../find/types/FindManyParams";
+import { FindOneParams } from "../find/types/FindOneParams";
+
+export type IncludeClause<
+    Models extends LooseModelDefinitions,
+    Relations extends LooseRelationsDefinitions<Models>,
+    M extends ModelName<Models>,
+> = {
+    [R in Extract<keyof Relations[M], string>]?: Relations[M][R] extends {
+        model: ModelName<Models>;
+    }
+        ? Relations[M][R] extends { type: "N:1" }
+            ? FindOneParams<Models, Relations, Relations[M][R]["model"]>
+            : Relations[M][R] extends { type: "1:N" }
+              ? FindManyParams<Models, Relations, Relations[M][R]["model"]>
+              : Relations[M][R] extends { type: "N:N" }
+                ? FindManyParams<Models, Relations, Relations[M][R]["model"]>
+                : never
+        : never;
+};

package/src/queries/clauses/LateralByClause.ts

@@ -0,0 +1,4 @@
+export type LateralByClause = {
+    column: string;
+    values: unknown[];
+}[];

package/src/queries/clauses/ReturningClause.ts

@@ -0,0 +1,9 @@
+import { ColumnName } from "../../schema/types/helpers/ColumnName";
+import { ModelName } from "../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../schema/types/loose/LooseModelDefinitions";
+import { NonEmptyArray } from "../../types/util/NonEmptyArray";
+
+export type ReturningClause<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+> = NonEmptyArray<ColumnName<Models, M>>;

package/src/queries/clauses/SelectClause.ts

@@ -0,0 +1,9 @@
+import { ColumnName } from "../../schema/types/helpers/ColumnName";
+import { ModelName } from "../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../schema/types/loose/LooseModelDefinitions";
+import { NonEmptyArray } from "../../types/util/NonEmptyArray";
+
+export type SelectClause<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+> = NonEmptyArray<ColumnName<Models, M>>;

package/src/queries/clauses/WhereClause.ts

@@ -0,0 +1,16 @@
+import { ColumnName } from "../../schema/types/helpers/ColumnName";
+import { ModelName } from "../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../schema/types/loose/LooseModelDefinitions";
+import { $and, $not, $or } from "../clauses/where/operators";
+import { WhereClauseValue } from "./where/types/WhereClauseValue";
+
+export type WhereClause<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+> = {
+    [C in ColumnName<Models, M>]?: WhereClauseValue<Models, M, C>;
+} & {
+    [$and]?: WhereClause<Models, M>[];
+    [$or]?: WhereClause<Models, M>[];
+    [$not]?: WhereClause<Models, M>;
+};

package/src/queries/clauses/helpers/ModelValues.ts

@@ -0,0 +1,9 @@
+import { ColumnName } from "../../../schema/types/helpers/ColumnName";
+import { ColumnType } from "../../../schema/types/helpers/ColumnType";
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+
+export type ModelValues<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+> = { [C in ColumnName<Models, M>]: ColumnType<Models, M, C> };

package/src/queries/clauses/helpers/OptionalColumn.ts

@@ -0,0 +1,19 @@
+import { ColumnName } from "../../../schema/types/helpers/ColumnName";
+import { HasDefault } from "../../../schema/types/helpers/HasDefault";
+import { IsNullable } from "../../../schema/types/helpers/IsNullable";
+import { IsSerial } from "../../../schema/types/helpers/IsSerial";
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+
+export type OptionalColumn<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+> = {
+    [C in ColumnName<Models, M>]: IsNullable<Models, M, C> extends true
+        ? C
+        : IsSerial<Models, M, C> extends true
+          ? C
+          : HasDefault<Models, M, C> extends true
+            ? C
+            : never;
+}[ColumnName<Models, M>];