@casekit/orm 0.0.1-alpha.12 → 0.0.1-alpha.14

package/src/migrate/sql/createForeignKeyConstraintSql.test.ts

@@ -1,50 +0,0 @@
-import { unindent } from "@casekit/unindent";
-
-import pg from "pg";
-import { describe, expect, test } from "vitest";
-
-import { ModelDefinition, orm, sql } from "../../";
-import { createForeignKeyConstraintSql } from "./createForeignKeyConstraintSql";
-
-describe("createForeignKeyConstraintSql", () => {
-    test("it generates an ALTER TABLE command for the specified foreign key constraint", () => {
-        const foo = {
-            schema: "casekit",
-            columns: {
-                id: { type: "uuid" },
-                barId: {
-                    name: "bar_id",
-                    type: "uuid",
-                    references: { table: "bar", column: "id" },
-                },
-                bazId: {
-                    name: "baz_id",
-                    type: "uuid",
-                    references: { table: "baz", column: "id" },
-                },
-            },
-            foreignKeys: [
-                {
-                    columns: ["bar_id", "baz_id"],
-                    references: {
-                        table: "quux",
-                        columns: ["bar_id", "baz_id"],
-                    },
-                    onUpdate: sql`CASCADE`,
-                },
-            ],
-        } as const satisfies ModelDefinition;
-
-        const db = orm({ models: { foo }, pool: new pg.Pool() });
-
-        const result = db.models.foo.foreignKeys
-            .map((fk) => createForeignKeyConstraintSql(db.models.foo, fk).text)
-            .join("\n");
-
-        expect(result).toEqual(unindent`
-             ALTER TABLE casekit.foo ADD CONSTRAINT foo_bar_id_baz_id_fkey FOREIGN KEY (bar_id, baz_id) REFERENCES casekit.quux (bar_id, baz_id) ON UPDATE CASCADE;
-             ALTER TABLE casekit.foo ADD CONSTRAINT foo_bar_id_fkey FOREIGN KEY (bar_id) REFERENCES casekit.bar (id);
-             ALTER TABLE casekit.foo ADD CONSTRAINT foo_baz_id_fkey FOREIGN KEY (baz_id) REFERENCES casekit.baz (id);
-        `);
-    });
-});

package/src/migrate/sql/createForeignKeyConstraintSql.ts

@@ -1,44 +0,0 @@
-import pgfmt from "pg-format";
-
-import { SQLStatement } from "../..";
-import { BaseModel } from "../../schema/types/base/BaseModel";
-import { ForeignKey } from "../../schema/types/constraints/ForeignKey";
-
-export const createForeignKeyConstraintSql = (
-    model: BaseModel,
-    constraint: ForeignKey,
-) => {
-    const statement = new SQLStatement();
-    statement.push(
-        pgfmt(`ALTER TABLE %I.%I ADD CONSTRAINT `, model.schema, model.table),
-    );
-
-    statement.push(
-        pgfmt("%I", [model.table, ...constraint.columns, "fkey"].join("_")),
-    );
-
-    statement.push(pgfmt(` FOREIGN KEY (`, model.schema, model.table));
-    statement.push(constraint.columns.map((c) => pgfmt("%I", c)).join(", "));
-    statement.push(")");
-    statement.push(
-        pgfmt(
-            ` REFERENCES %I.%I (`,
-            constraint.references.schema,
-            constraint.references.table,
-        ),
-    );
-    statement.push(
-        constraint.references.columns.map((c) => pgfmt("%I", c)).join(", "),
-    );
-    statement.push(")");
-    if (constraint.onDelete) {
-        statement.push(` ON DELETE `);
-        statement.push(constraint.onDelete);
-    }
-    if (constraint.onUpdate) {
-        statement.push(` ON UPDATE `);
-        statement.push(constraint.onUpdate);
-    }
-    statement.push(";");
-    return statement;
-};

package/src/migrate/sql/createSchemasSql.test.ts

@@ -1,81 +0,0 @@
-import { unindent } from "@casekit/unindent";
-
-import pg from "pg";
-import { describe, expect, test } from "vitest";
-import { z } from "zod";
-
-import { ModelDefinition, orm } from "../../";
-import { createSchemasSql } from "./createSchemasSql";
-
-describe("createSchemaSql", () => {
-    test("it generates a CREATE SCHEMA command for each unique schema used", () => {
-        const a = {
-            schema: "foo",
-            columns: {
-                id: { type: "uuid", zodSchema: z.string() },
-            },
-        } as const satisfies ModelDefinition;
-
-        const b = {
-            schema: "bar",
-            columns: {
-                id: { type: "uuid", zodSchema: z.string() },
-            },
-        } as const satisfies ModelDefinition;
-
-        const db = orm({ models: { a, b }, pool: new pg.Pool() });
-        expect(createSchemasSql(db).text).toEqual(unindent`
-            CREATE SCHEMA IF NOT EXISTS foo;
-            CREATE SCHEMA IF NOT EXISTS bar;
-        `);
-    });
-
-    test("it pulls schema from the config if not specified on the model", () => {
-        const a = {
-            columns: {
-                id: { type: "uuid", zodSchema: z.string() },
-            },
-        } as const satisfies ModelDefinition;
-
-        const b = {
-            schema: "bar",
-            columns: {
-                id: { type: "uuid", zodSchema: z.string() },
-            },
-        } as const satisfies ModelDefinition;
-
-        const db = orm({
-            schema: "foo",
-            models: { a, b },
-            pool: new pg.Pool(),
-        });
-        expect(createSchemasSql(db).text).toEqual(unindent`
-            CREATE SCHEMA IF NOT EXISTS foo;
-            CREATE SCHEMA IF NOT EXISTS bar;
-        `);
-    });
-
-    test("if no schema is specified at all, it tries to create the public schema", () => {
-        const a = {
-            columns: {
-                id: { type: "uuid", zodSchema: z.string() },
-            },
-        } as const satisfies ModelDefinition;
-
-        const b = {
-            schema: "bar",
-            columns: {
-                id: { type: "uuid", zodSchema: z.string() },
-            },
-        } as const satisfies ModelDefinition;
-
-        const db = orm({
-            models: { a, b },
-            pool: new pg.Pool(),
-        });
-        expect(createSchemasSql(db).text).toEqual(unindent`
-            CREATE SCHEMA IF NOT EXISTS public;
-            CREATE SCHEMA IF NOT EXISTS bar;
-        `);
-    });
-});

package/src/migrate/sql/createSchemasSql.ts

@@ -1,15 +0,0 @@
-import { uniq } from "lodash-es";
-import pgfmt from "pg-format";
-
-import { BaseOrm } from "../../schema/types/base/BaseOrm";
-import { SQLStatement } from "../../sql";
-
-export const createSchemasSql = (db: BaseOrm): SQLStatement => {
-    const schemas = uniq(Object.values(db.models).map((m) => m.schema));
-
-    return new SQLStatement(
-        schemas
-            .map((s) => pgfmt("CREATE SCHEMA IF NOT EXISTS %I;", s))
-            .join("\n"),
-    );
-};

package/src/migrate/sql/createTableSql.properties.ts

@@ -1,38 +0,0 @@
-import { test } from "@fast-check/vitest";
-import { isEqual } from "lodash-es";
-import pg from "pg";
-import pgfmt from "pg-format";
-
-import { orm } from "../..";
-import * as gen from "../../test/gen";
-import { withRollback } from "../../test/util/withRollback";
-import { createSchemasSql } from "./createSchemasSql";
-import { createTableSql } from "./createTableSql";
-
-test.prop([gen.model()])("should generate valid DDL", async (model) => {
-    return await withRollback(async (client) => {
-        const db = orm({
-            models: { model },
-            relations: { model: {} },
-
-            pool: new pg.Pool(),
-        });
-
-        // create the schema
-        await client.query(createSchemasSql(db));
-
-        // create the table
-        await client.query(createTableSql(db.models.model));
-
-        // select from the newly created table so we can check it's there
-        const result = await client.query(
-            pgfmt("select * from %I.%I", model.schema, model.table),
-        );
-
-        // the selected fields should match the ones defined in the model
-        return isEqual(
-            result.fields.map((f) => f.name),
-            Object.values(model.columns).map((c) => c.name),
-        );
-    });
-});

package/src/migrate/sql/createTableSql.test.ts

@@ -1,74 +0,0 @@
-import { unindent } from "@casekit/unindent";
-
-import { snakeCase, uniqueId } from "lodash-es";
-import pg from "pg";
-import { describe, expect, test } from "vitest";
-import { z } from "zod";
-
-import { ModelDefinition, orm } from "../..";
-import { sql } from "../../sql";
-import { db } from "../../test/db";
-import { createTableSql } from "./createTableSql";
-
-describe("createTableSql", () => {
-    test("it generates a CREATE TABLE command", () => {
-        expect(createTableSql(db.models.user).text).toEqual(unindent`
-            CREATE TABLE casekit."user" (
-                id uuid NOT NULL DEFAULT uuid_generate_v4(),
-                username text NOT NULL,
-                invited_by_id uuid,
-                created_at timestamp,
-                updated_at timestamp,
-                deleted_at timestamp,
-                PRIMARY KEY (id)
-            );
-        `);
-    });
-
-    test("the generated DDL successfully creates a table", async () => {
-        const table = uniqueId("table-");
-        const post = {
-            table,
-            columns: {
-                id: {
-                    zodSchema: z.string().uuid(),
-                    type: "uuid",
-                    default: sql`uuid_generate_v4()`,
-                },
-                title: {
-                    zodSchema: z.string(),
-                    type: "text",
-                    default: "My first post",
-                },
-                content: { zodSchema: z.string(), type: "text" },
-                publishedAt: {
-                    zodSchema: z.date(),
-                    type: "timestamp",
-                    nullable: true,
-                },
-            },
-        } as const satisfies ModelDefinition;
-        await orm({
-            models: { post },
-            relations: { post: {} },
-            naming: { column: snakeCase },
-            pool: new pg.Pool(),
-        }).transact(
-            async (db) => {
-                await db.connection.query(createTableSql(db.models.post));
-
-                const result = await db.connection.query(
-                    sql`select * from public.%I`.withIdentifiers(table),
-                );
-
-                expect(result.fields.map((f) => f.name)).toEqual([
-                    "id",
-                    "title",
-                    "content",
-                    "published_at",
-                ]);
-            },
-            { rollback: true },
-        );
-    });
-});

package/src/migrate/sql/createTableSql.ts

@@ -1,53 +0,0 @@
-import pgfmt from "pg-format";
-
-import { BaseModel } from "../../schema/types/base/BaseModel";
-import { SQLStatement } from "../../sql";
-import { interleave } from "../../util/interleave";
-
-export const createTableSql = (model: BaseModel): SQLStatement => {
-    const columns = Object.values(model.columns);
-    const primaryKey = model.primaryKey;
-
-    const statement = new SQLStatement();
-
-    statement.push(
-        pgfmt("CREATE TABLE %I.%I (\n", model.schema ?? "public", model.table),
-    );
-
-    statement.push(
-        ...interleave(
-            columns.map((column) => {
-                const definition = new SQLStatement(
-                    pgfmt(`    %I %s`, column.name, column.type),
-                );
-
-                if (!column.nullable) definition.push(pgfmt(" NOT NULL"));
-
-                if (column.default instanceof SQLStatement) {
-                    definition.push(" DEFAULT ");
-                    definition.push(column.default);
-                } else if (
-                    column.default !== null &&
-                    column.default !== undefined
-                ) {
-                    definition.push(pgfmt(" DEFAULT %L", column.default));
-                }
-                return definition;
-            }),
-            ",\n",
-        ),
-    );
-
-    if (primaryKey.length > 0) {
-        statement.push(
-            pgfmt(
-                `,\n    PRIMARY KEY (${primaryKey.map(() => "%I").join(", ")})`,
-                ...primaryKey,
-            ),
-        );
-    }
-
-    statement.push(pgfmt("\n);"));
-
-    return statement;
-};

package/src/migrate/sql/createUniqueConstraintSql.ts

@@ -1,27 +0,0 @@
-import pgfmt from "pg-format";
-
-import { SQLStatement } from "../..";
-import { BaseModel } from "../../schema/types/base/BaseModel";
-import { UniqueConstraint } from "../../schema/types/constraints/UniqueConstraint";
-
-export const createUniqueConstraintSql = (
-    model: BaseModel,
-    constraint: UniqueConstraint,
-) => {
-    const statement = new SQLStatement();
-    statement.push(
-        pgfmt(`CREATE UNIQUE INDEX ON %I.%I (`, model.schema, model.table),
-    );
-    statement.push(constraint.columns.map((c) => pgfmt("%I", c)).join(", "));
-    statement.push(")");
-    if (constraint.nullsNotDistinct) {
-        statement.push(" NULLS NOT DISTINCT");
-    }
-    if (constraint.where) {
-        statement.push(" WHERE (");
-        statement.push(constraint.where);
-        statement.push(")");
-    }
-    statement.push(";");
-    return statement;
-};

package/src/migrate/sql/dropSchemasSql.ts

@@ -1,15 +0,0 @@
-import { uniq } from "lodash-es";
-import pgfmt from "pg-format";
-
-import { BaseOrm } from "../../schema/types/base/BaseOrm";
-import { SQLStatement } from "../../sql";
-
-export const dropSchemasSql = (db: BaseOrm): SQLStatement => {
-    const schemas = uniq(Object.values(db.models).map((m) => m.schema));
-
-    return new SQLStatement(
-        schemas
-            .map((s) => pgfmt("DROP SCHEMA IF EXISTS %I CASCADE;", s))
-            .join("\n"),
-    );
-};

package/src/migrate/sql/dropTableSql.ts

@@ -1,13 +0,0 @@
-import pgfmt from "pg-format";
-
-import { BaseModel } from "../../schema/types/base/BaseModel";
-import { SQLStatement } from "../../sql";
-
-export const dropTableSql = (model: BaseModel): SQLStatement => {
-    const statement = pgfmt(
-        "DROP TABLE IF EXISTS %I.%I CASCADE;",
-        model.schema ?? "public",
-        model.table,
-    );
-    return new SQLStatement(statement);
-};

package/src/orm.query.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import { db } from "./test/db";
-import { seed } from "./test/seed";
-
-describe("orm.query", () => {
-    test("allows arbitrary sql queries to be run against the database", async () => {
-        await db.transact(
-            async (db) => {
-                await seed(db, {
-                    users: [
-                        {
-                            username: "Russell",
-                            tenants: [{ name: "Popova Park", posts: 6 }],
-                        },
-                    ],
-                });
-
-                const result = await db.query<{ total: number }>`
-                    select count(1)::int as total from casekit.post;
-                `;
-
-                expect(result[0]).toEqual({ total: 6 });
-            },
-            { rollback: true },
-        );
-    });
-});