@casekit/orm 0.0.1-alpha.0

package/src/test/db/models/foo.model.ts

@@ -0,0 +1,24 @@
+import { ModelDefinition } from "../../..";
+import { sql } from "../../../sql";
+
+export const foo = {
+    columns: {
+        id: {
+            type: "uuid",
+            default: sql`uuid_generate_v4()`,
+            primaryKey: true,
+        },
+        bigint: { type: "bigint" },
+        text: { type: "text" },
+        timestamp: { type: "timestamp" },
+        renamedColumn: { name: "original_name", type: "timestamp" },
+        a: { type: "bigint" },
+        b: { type: "bigint" },
+        c: { type: "bigint" },
+        d: { type: "bigint" },
+        e: { type: "bigint" },
+        f: { type: "bigint" },
+        g: { type: "bigint" },
+        h: { type: "bigint" },
+    },
+} as const satisfies ModelDefinition;

package/src/test/db/models/foo.relations.ts

@@ -0,0 +1,4 @@
+import { RelationsDefinition } from "../../../schema/types/strict/RelationsDefinition";
+import { Models } from "../models";
+
+export const foo = {} as const satisfies RelationsDefinition<Models, "foo">;

package/src/test/db/models/post.model.ts

@@ -0,0 +1,28 @@
+import { ModelDefinition } from "../../../schema/types/strict/ModelDefinition";
+import { sql } from "../../../sql";
+
+export const post = {
+    columns: {
+        id: {
+            type: "uuid",
+            default: sql`uuid_generate_v4()`,
+            primaryKey: true,
+        },
+        title: { type: "text" },
+        content: { type: "text" },
+        authorId: {
+            name: "created_by_id",
+            type: "uuid",
+            references: { table: "user", column: "id" },
+        },
+        publishedAt: { type: "timestamp", nullable: true },
+        tags: { type: "text[][][][]", nullable: true },
+        tenantId: {
+            type: "uuid",
+            references: { table: "tenant", column: "id" },
+            default: "00000000-0000-0000-0000-000000000000",
+        },
+        updatedAt: { type: "timestamp", nullable: true },
+        deletedAt: { type: "timestamp", nullable: true },
+    },
+} as const satisfies ModelDefinition;

package/src/test/db/models/post.relations.ts

@@ -0,0 +1,15 @@
+import { RelationsDefinition } from "../../../schema/types/strict/RelationsDefinition";
+import { Models } from "../models";
+
+export const post = {
+    author: {
+        model: "user",
+        type: "N:1",
+        foreignKey: "authorId",
+    },
+    tenant: {
+        model: "tenant",
+        type: "N:1",
+        foreignKey: "tenantId",
+    },
+} as const satisfies RelationsDefinition<Models, "post">;

package/src/test/db/models/tenant.model.ts

@@ -0,0 +1,14 @@
+import { ModelDefinition } from "../../../schema/types/strict/ModelDefinition";
+import { sql } from "../../../sql";
+
+export const tenant = {
+    columns: {
+        id: {
+            type: "uuid",
+            default: sql`uuid_generate_v4()`,
+            primaryKey: true,
+        },
+        name: { type: "text" },
+        createdAt: { type: "timestamp", default: sql`now()` },
+    },
+} as const satisfies ModelDefinition;

package/src/test/db/models/tenant.relations.ts

@@ -0,0 +1,22 @@
+import { RelationsDefinition } from "../../../schema/types/strict/RelationsDefinition";
+import { Models } from "../models";
+
+export const tenant = {
+    users: {
+        model: "user",
+        through: "tenantUser",
+        type: "N:N",
+        foreignKey: "tenantId",
+        otherKey: "userId",
+    },
+    tenancies: {
+        model: "tenantUser",
+        type: "1:N",
+        foreignKey: "tenantId",
+    },
+    posts: {
+        model: "post",
+        type: "1:N",
+        foreignKey: "tenantId",
+    },
+} as const satisfies RelationsDefinition<Models, "tenant">;

package/src/test/db/models/tenantUser.model.ts

@@ -0,0 +1,23 @@
+import { ModelDefinition } from "../../../schema/types/strict/ModelDefinition";
+import { sql } from "../../../sql";
+
+export const tenantUser = {
+    table: "tenant_user",
+    columns: {
+        id: {
+            type: "uuid",
+            default: sql`uuid_generate_v4()`,
+            primaryKey: true,
+        },
+        tenantId: {
+            type: "uuid",
+            references: { table: "tenant", column: "id" },
+        },
+        userId: { type: "uuid", references: { table: "user", column: "id" } },
+        createdAt: { type: "timestamp with time zone", default: sql`now()` },
+        deletedAt: {
+            type: "timestamp with time zone",
+            nullable: true,
+        },
+    },
+} as const satisfies ModelDefinition;

package/src/test/db/models/tenantUser.relations.ts

@@ -0,0 +1,15 @@
+import { RelationsDefinition } from "../../../schema/types/strict/RelationsDefinition";
+import { Models } from "../models";
+
+export const tenantUser = {
+    user: {
+        model: "user",
+        type: "N:1",
+        foreignKey: "userId",
+    },
+    tenant: {
+        model: "tenant",
+        type: "N:1",
+        foreignKey: "tenantId",
+    },
+} as const satisfies RelationsDefinition<Models, "tenantUser">;

package/src/test/db/models/user.model.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+
+import { ModelDefinition } from "../../../schema/types/strict/ModelDefinition";
+import { sql } from "../../../sql";
+
+export const user = {
+    columns: {
+        id: { type: "uuid", default: sql`uuid_generate_v4()` },
+        username: { zodSchema: z.string(), type: "text" },
+        joinedAt: {
+            name: "created_at",
+            zodSchema: z.date(),
+            type: "timestamp",
+            nullable: true,
+        },
+        updatedAt: { type: "timestamp", nullable: true },
+        deletedAt: { zodSchema: z.date(), type: "timestamp", nullable: true },
+    },
+    primaryKey: ["id"],
+    uniqueConstraints: [
+        { columns: ["username"], where: sql`deleted_at IS NULL` },
+    ],
+} as const satisfies ModelDefinition;

package/src/test/db/models/user.relations.ts

@@ -0,0 +1,22 @@
+import { RelationsDefinition } from "../../../schema/types/strict/RelationsDefinition";
+import { Models } from "../models";
+
+export const user = {
+    posts: {
+        type: "1:N",
+        model: "post",
+        foreignKey: "authorId",
+    },
+    tenancies: {
+        type: "1:N",
+        model: "tenantUser",
+        foreignKey: "userId",
+    },
+    tenants: {
+        type: "N:N",
+        model: "tenant",
+        through: "tenantUser",
+        foreignKey: "userId",
+        otherKey: "tenantId",
+    },
+} as const satisfies RelationsDefinition<Models, "user">;

package/src/test/db/models.ts

@@ -0,0 +1,15 @@
+import { foo } from "./models/foo.model";
+import { post } from "./models/post.model";
+import { tenant } from "./models/tenant.model";
+import { tenantUser } from "./models/tenantUser.model";
+import { user } from "./models/user.model";
+
+export const models = {
+    foo,
+    post,
+    user,
+    tenant,
+    tenantUser,
+};
+
+export type Models = typeof models;

package/src/test/db/relations.ts

@@ -0,0 +1,13 @@
+import { post } from "./models/post.relations";
+import { tenant } from "./models/tenant.relations";
+import { tenantUser } from "./models/tenantUser.relations";
+import { user } from "./models/user.relations";
+
+export const relations = {
+    post,
+    user,
+    tenant,
+    tenantUser,
+};
+
+export type Relations = typeof relations;

package/src/test/gen/column.ts

@@ -0,0 +1,39 @@
+import { fc } from "@fast-check/vitest";
+import { z } from "zod";
+
+import { LooseColumnDefinition } from "../../schema/types/loose/LooseColumnDefinition";
+import { DataType } from "../../schema/types/postgres/DataType";
+import { sqldate } from "./sqldate";
+
+export const column = () => {
+    return fc.oneof(
+        fc.record<LooseColumnDefinition>({
+            name: fc.string({ minLength: 1, maxLength: 80 }),
+            nullable: fc.boolean(),
+            zodSchema: fc.constant(z.string()),
+            type: fc.constant<DataType>("text"),
+            default: fc.oneof(fc.string(), fc.constant(null)),
+        }),
+        fc.record<LooseColumnDefinition>({
+            name: fc.string({ minLength: 1, maxLength: 80 }),
+            nullable: fc.boolean(),
+            zodSchema: fc.constant(z.string().uuid()),
+            type: fc.constant<DataType>("uuid"),
+            default: fc.oneof(fc.uuid(), fc.constant(null)),
+        }),
+        fc.record<LooseColumnDefinition>({
+            name: fc.string({ minLength: 1, maxLength: 80 }),
+            nullable: fc.boolean(),
+            zodSchema: fc.constant(z.number()),
+            type: fc.constant<DataType>("bigint"),
+            default: fc.oneof(fc.integer(), fc.constant(null)),
+        }),
+        fc.record<LooseColumnDefinition>({
+            name: fc.string({ minLength: 1, maxLength: 80 }),
+            nullable: fc.boolean(),
+            zodSchema: fc.constant(z.date()),
+            type: fc.constant<DataType>("timestamp"),
+            default: fc.oneof(sqldate(), fc.constant(null)),
+        }),
+    );
+};

package/src/test/gen/index.ts

@@ -0,0 +1,2 @@
+export { column } from "./column";
+export { model } from "./model";

package/src/test/gen/model.ts

@@ -0,0 +1,58 @@
+import { fc } from "@fast-check/vitest";
+import { drop, take, uniqBy } from "lodash-es";
+
+import { UniqueConstraint } from "../../schema/types/constraints/UniqueConstraint";
+import { LooseModelDefinition } from "../../schema/types/loose/LooseModelDefinition";
+import { column } from "./column";
+
+export const model = () => {
+    return fc
+        .tuple(
+            fc.record<LooseModelDefinition>({
+                table: fc.string({ minLength: 1, maxLength: 80 }),
+                schema: fc.string({ minLength: 1, maxLength: 80 }),
+                columns: fc.dictionary(fc.string({ minLength: 1 }), column(), {
+                    minKeys: 1,
+                    maxKeys: 65,
+                }),
+                primaryKey: fc.constant([]),
+                uniqueConstraints: fc.constant([]),
+                foreignKeys: fc.constant([]),
+            }),
+            fc.integer({ min: 1, max: 2 }), // no of primary keys
+            fc.integer({ min: 0, max: 2 }), // no of unique constraints
+        )
+        .map<LooseModelDefinition>(
+            ([model, numPrimaryKeyColumns, numUniqueColumns]) => {
+                // remove any duplicate column names
+                const columns = uniqBy(
+                    Object.entries(model.columns),
+                    ([, c]) => c.name,
+                );
+
+                // take the first n columns as the primary key, if one has been specified
+                const primaryKeyColumns = take(columns, numPrimaryKeyColumns);
+
+                // and columns after it as the unique columns, if they have been specified
+                const uniqueKeyColumns = take(
+                    drop(columns, numPrimaryKeyColumns),
+                    numUniqueColumns,
+                );
+
+                const primaryKey = primaryKeyColumns.map(
+                    ([, c]) => c.name as string,
+                );
+
+                const uniqueConstraints = uniqueKeyColumns.map(([, c]) => ({
+                    columns: [c.name as string],
+                })) as UniqueConstraint[];
+
+                return {
+                    ...model,
+                    columns: Object.fromEntries(columns),
+                    primaryKey,
+                    uniqueConstraints,
+                };
+            },
+        );
+};

package/src/test/gen/sqldate.ts

@@ -0,0 +1,8 @@
+import { fc } from "@fast-check/vitest";
+
+export const sqldate = () =>
+    fc.date({
+        min: new Date("1970-01-01T00:00:00.000Z"),
+        max: new Date("9999-01-01T00:00:00.000Z"),
+        noInvalidDate: true,
+    });

package/src/test/globalSetup.ts

@@ -0,0 +1,6 @@
+import { migrator } from "..";
+import { db } from "./db";
+
+export default async function setup() {
+    await migrator(db).implode({ dryRun: false, output: true });
+}

package/src/test/seed/index.ts

@@ -0,0 +1,75 @@
+import { keyBy, times, uniq } from "lodash-es";
+
+import { DB } from "../db";
+
+export type SeedParams = {
+    users: {
+        username: string;
+        tenants: {
+            name: string;
+            posts: number;
+        }[];
+    }[];
+};
+
+export const seed = async (
+    db: DB,
+    params: SeedParams,
+): Promise<{
+    users: Record<string, { id: string; username: string }>;
+    tenants: Record<string, { id: string; name: string }>;
+    tenantUsers: { userId: string; tenantId: string }[];
+    posts: { id: string; title: string; content: string; authorId: string }[];
+}> => {
+    const tenants = keyBy(
+        await db.createMany("tenant", {
+            values: uniq(params.users.flatMap((u) => u.tenants)).map(
+                (tenant) => ({ name: tenant.name }),
+            ),
+            returning: ["id", "name", "createdAt"],
+        }),
+        "name",
+    );
+
+    const users = keyBy(
+        await db.createMany("user", {
+            values: uniq(
+                params.users.map((user) => ({ username: user.username })),
+            ),
+            returning: ["id", "username"],
+        }),
+        "username",
+    );
+
+    const tenantUsers = await db.createMany("tenantUser", {
+        values: params.users.flatMap((user) => {
+            return user.tenants.map((tenant) => ({
+                userId: users[user.username].id,
+                tenantId: tenants[tenant.name].id,
+            }));
+        }),
+        returning: ["id", "userId", "tenantId"],
+    });
+
+    let postIndex = 0;
+    const posts = await db.createMany("post", {
+        values: params.users.flatMap((user) =>
+            user.tenants.flatMap((tenant) =>
+                times(tenant.posts, () => {
+                    const letter = String.fromCharCode(
+                        "a".charCodeAt(0) + postIndex++,
+                    );
+                    return {
+                        title: `Post ${letter}`,
+                        content: `This is the content of post ${letter}`,
+                        authorId: users[user.username].id,
+                        tenantId: tenants[tenant.name].id,
+                    };
+                }),
+            ),
+        ),
+        returning: ["id", "title", "content", "authorId"],
+    });
+
+    return { users, tenants, tenantUsers, posts };
+};

package/src/test/util/withRollback.ts

@@ -0,0 +1,18 @@
+import pg from "pg";
+
+export const withRollback = async <T>(
+    cb: (client: pg.Client) => Promise<T>,
+): Promise<T> => {
+    const client = new pg.Client();
+    try {
+        await client.connect();
+        await client.query("BEGIN");
+        return await cb(client);
+    } finally {
+        try {
+            await client.query("ROLLBACK");
+        } finally {
+            await client.end();
+        }
+    }
+};

package/src/test/util/withTransaction.ts

@@ -0,0 +1,19 @@
+import pg from "pg";
+
+export const withTransaction = async <T>(
+    cb: (client: pg.Client) => Promise<T>,
+): Promise<T> => {
+    const client = new pg.Client();
+    try {
+        await client.connect();
+        await client.query("BEGIN");
+        const result = await cb(client);
+        await client.query("COMMIT");
+        return result;
+    } catch (e) {
+        await client.query("ROLLBACK");
+        throw e;
+    } finally {
+        await client.end();
+    }
+};

package/src/types/ColumnName.ts

@@ -0,0 +1,6 @@
+import { LooseModelDefinition } from "../schema/types/loose/LooseModelDefinition";
+
+export type ColumnName<Model extends LooseModelDefinition> = Extract<
+    keyof Model["columns"],
+    string
+>;

package/src/types/ColumnType.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+
+import { SuggestedColumnType } from "../schema/populate/suggestedColumnSchema";
+import { LooseModelDefinition } from "../schema/types/loose/LooseModelDefinition";
+import { ColumnName } from "./ColumnName";
+
+type NonNullableColumnType<
+    Model extends LooseModelDefinition,
+    C extends ColumnName<Model>,
+> =
+    Model["columns"][C]["zodSchema"] extends z.ZodType<unknown>
+        ? z.infer<Model["columns"][C]["zodSchema"]>
+        : SuggestedColumnType<Model["columns"][C]["type"]>;
+
+export type ColumnType<
+    Model extends LooseModelDefinition,
+    C extends ColumnName<Model>,
+> = Model["columns"][C]["nullable"] extends true
+    ? NonNullableColumnType<Model, C> | null
+    : NonNullableColumnType<Model, C>;

package/src/types/Configuration.ts

@@ -0,0 +1,21 @@
+import pg from "pg";
+
+import { Middleware } from "../queries/middleware/Middleware";
+import { LooseModelDefinitions } from "../schema/types/loose/LooseModelDefinitions";
+import { LooseRelationsDefinitions } from "../schema/types/loose/LooseRelationsDefinitions";
+
+export type Configuration<
+    Models extends LooseModelDefinitions,
+    Relations extends LooseRelationsDefinitions<Models>,
+> = {
+    models: Models;
+    relations?: Relations;
+    extensions?: string[];
+    schema?: string;
+    naming?: {
+        column?: (s: string) => string;
+        table?: (s: string) => string;
+    };
+    pool: pg.Pool;
+    middleware?: Middleware[];
+};

package/src/types/ModelType.ts

@@ -0,0 +1,7 @@
+import { LooseModelDefinition } from "../schema/types/loose/LooseModelDefinition";
+import { ColumnName } from "./ColumnName";
+import { ColumnType } from "./ColumnType";
+
+export type ModelType<Model extends LooseModelDefinition> = {
+    [C in ColumnName<Model>]: ColumnType<Model, C>;
+};

package/src/types/util/DeepRequired.ts

@@ -0,0 +1,7 @@
+export type DeepRequired<T> = T extends (...args: unknown[]) => unknown
+    ? T
+    : T extends Record<string, unknown>
+      ? { [K in keyof T]-?: Exclude<DeepRequired<T[K]>, null | undefined> }
+      : T extends [infer Head, ...infer Tail]
+        ? [DeepRequired<Head>, ...DeepRequired<Tail>]
+        : T;

package/src/types/util/DisallowExtraKeys.ts

@@ -0,0 +1,5 @@
+export type DisallowExtraKeys<Base, T extends Base> = {
+    [K in keyof T]: T[K];
+} & {
+    [K in keyof T as K extends keyof Base ? never : K]: never;
+};

package/src/types/util/NonEmptyArray.ts

@@ -0,0 +1 @@
+export type NonEmptyArray<T> = [T, ...T[]];

package/src/types/util/Simplify.ts

@@ -0,0 +1,8 @@
+export type Simplify<T> = {
+    [K in keyof T]: T[K] extends Date
+        ? T[K]
+        : T[K] extends object
+          ? Simplify<T[K]>
+          : T[K];
+    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+} & unknown;

package/src/util/ensureArray.ts

@@ -0,0 +1,4 @@
+/**
+ * Ensure that the input is an array. If it is not an array, wrap it in an array.
+ */
+export const ensureArray = <T>(x: T | T[]): T[] => (Array.isArray(x) ? x : [x]);

package/src/util/interleave.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "vitest";
+
+import { interleave } from "./interleave";
+
+describe("interleave", () => {
+    test("it interleaves a value between elements of a list", () => {
+        expect(interleave([1, 2, 3], "x")).toEqual([1, "x", 2, "x", 3]);
+    });
+
+    test("it works with empty lists", () => {
+        expect(interleave([], "x")).toEqual([]);
+    });
+
+    test("it works with long lists", () => {
+        expect(interleave([1, 2, 3, 1, 2, 3, 1, 2, 3], "x")).toEqual([
+            1,
+            "x",
+            2,
+            "x",
+            3,
+            "x",
+            1,
+            "x",
+            2,
+            "x",
+            3,
+            "x",
+            1,
+            "x",
+            2,
+            "x",
+            3,
+        ]);
+    });
+});

package/src/util/interleave.ts

@@ -0,0 +1,8 @@
+export const interleave = <T, U>(xs: T[], y: U): (T | U)[] => {
+    const zs: (T | U)[] = [];
+    xs.forEach((x, index) => {
+        zs.push(x);
+        if (index < xs.length - 1) zs.push(y);
+    });
+    return zs;
+};

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ESNext",
+        "sourceMap": true,
+        "outDir": "./lib",
+        "declaration": true,
+        "declarationMap": true,
+        "esModuleInterop": true,
+        "resolveJsonModule": true,
+        "moduleResolution": "Bundler",
+        "forceConsistentCasingInFileNames": true,
+        "strict": true,
+        "skipLibCheck": true,
+        "baseUrl": "./"
+    },
+    "include": ["src"]
+}

package/vitest.config.ts

@@ -0,0 +1,15 @@
+/// <reference types="vitest" />
+import "dotenv/config";
+import tsconfigPaths from "vite-tsconfig-paths";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+    plugins: [tsconfigPaths()],
+    test: {
+        // ... Specify options here.
+        include: ["**/*.(spec|test|properties).ts?(x)"],
+	exclude: ["lib", "node_modules"],
+        globalSetup: "src/test/globalSetup.ts",
+        coverage: { provider: "istanbul" },
+    },
+});