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

package/src/sql/SQLStatement.ts

@@ -1,86 +0,0 @@
-/**
- * This file is heavily inspired by felixfbecker/node-sql-template-strings,
- * which has the following licence:
- *
- * ISC License
- * Copyright (c) 2016, Felix Frederick Becker
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-import pgfmt from "pg-format";
-
-export class SQLStatement {
-    public fragments: string[];
-    public values: unknown[];
-
-    constructor(
-        sql: readonly string[] | string = [],
-        values: readonly unknown[] = [],
-    ) {
-        this.fragments = typeof sql === "string" ? [sql] : [...sql];
-        this.values = [...values];
-    }
-
-    get text() {
-        return this.fragments.reduce((prev, curr, i) => prev + "$" + i + curr);
-    }
-
-    public push(...args: (SQLStatement | string | null)[]): SQLStatement {
-        for (const arg of args) {
-            if (arg === null) {
-                // do nothing - this case is here as a convenience
-                // for when using functions that might not have any
-                // SQL to return
-            } else if (typeof arg === "string") {
-                if (this.fragments.length === 0) {
-                    this.fragments.push(arg);
-                } else {
-                    this.fragments[this.fragments.length - 1] += arg;
-                }
-            } else {
-                if (arg.fragments.length === 0) {
-                    // do nothing - statement is empty
-                } else if (this.fragments.length === 0) {
-                    this.fragments.push(...arg.fragments);
-                    this.values.push(...arg.values);
-                } else {
-                    this.fragments[this.fragments.length - 1] +=
-                        arg.fragments[0];
-                    this.fragments.push(...arg.fragments.slice(1));
-                    this.values.push(...arg.values);
-                }
-            }
-        }
-        return this;
-    }
-
-    public withIdentifiers(...identifiers: string[]) {
-        const remainingIdentifiers = [...identifiers];
-        for (const index of this.fragments.keys()) {
-            const countPlaceholders =
-                this.fragments[index].match(/%I/g)?.length ?? 0;
-            if (countPlaceholders > 0) {
-                const interpolated = pgfmt(
-                    this.fragments[index],
-                    ...remainingIdentifiers.splice(0, countPlaceholders),
-                );
-                this.fragments[index] = interpolated;
-                if (remainingIdentifiers.length === 0) {
-                    break;
-                }
-            }
-        }
-
-        return this;
-    }
-}

package/src/sql/index.ts

@@ -1,2 +0,0 @@
-export { sql } from "./sql";
-export { SQLStatement } from "./SQLStatement";

package/src/sql/sql.ts

@@ -1,47 +0,0 @@
-import { interleave } from "../util/interleave";
-import { SQLStatement } from "./SQLStatement";
-
-export const sql = (
-    fragments: TemplateStringsArray,
-    ...variables: readonly unknown[]
-) => {
-    /**
-     * This complicated mess allows us to interpolate a SQLStatement
-     * inside a SQLStatement, which is v helpful in eloquently
-     * building up complex statements.
-     */
-    const expandedFragments: string[] = [];
-    const expandedVariables: unknown[] = [];
-    const remainingFragments = [...fragments];
-    const remainingVariables = [...variables];
-    let index = 0;
-
-    while (remainingFragments.length > 0) {
-        const fragment = remainingFragments.shift();
-        const variable = remainingVariables.shift();
-        expandedFragments[index] = (expandedFragments[index] ?? "") + fragment;
-        if (remainingFragments.length > 0) {
-            if (variable instanceof SQLStatement) {
-                if (variable.fragments.length > 0) {
-                    expandedFragments[index] += variable.fragments[0];
-                    expandedFragments.push(...variable.fragments.slice(1));
-                    expandedVariables.push(...variable.values);
-                    index += variable.fragments.length - 1;
-                }
-            } else {
-                expandedVariables.push(variable);
-                index += 1;
-            }
-        }
-    }
-
-    return new SQLStatement(expandedFragments, expandedVariables);
-};
-
-sql.splat = <T>(values: T[], separator = `, `) =>
-    new SQLStatement().push(
-        ...interleave(
-            values.map((v) => sql`${v}`),
-            separator,
-        ),
-    );

package/src/test/db/index.ts

@@ -1,27 +0,0 @@
-import { snakeCase } from "lodash-es";
-import pg from "pg";
-
-import { orm } from "../..";
-import { FindManyParams } from "../../queries/find/types/FindManyParams";
-import { ModelName } from "../../schema/types/helpers/ModelName";
-import { Models, models } from "./models";
-import { Relations, relations } from "./relations";
-
-export const db = orm({
-    models,
-    relations,
-    extensions: ["uuid-ossp"],
-    naming: { column: snakeCase },
-    schema: "casekit",
-    pool: new pg.Pool(),
-});
-
-export type FindMany<M extends ModelName<Models>> = FindManyParams<
-    Models,
-    Relations,
-    M
->;
-
-export { models, relations };
-export type { Models, Relations };
-export type DB = typeof db;

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

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

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

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

@@ -1,34 +0,0 @@
-import { ModelDefinition } from "../../..";
-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" },
-        },
-        reviewedById: {
-            name: "reviewed_by_id",
-            type: "uuid",
-            nullable: true,
-            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

@@ -1,21 +0,0 @@
-import { RelationsDefinition } from "../../..";
-import { Models } from "../models";
-
-export const post = {
-    author: {
-        model: "user",
-        type: "N:1",
-        foreignKey: "authorId",
-    },
-    reviewedBy: {
-        model: "user",
-        type: "N:1",
-        foreignKey: "reviewedById",
-        optional: true,
-    },
-    tenant: {
-        model: "tenant",
-        type: "N:1",
-        foreignKey: "tenantId",
-    },
-} as const satisfies RelationsDefinition<Models, "post">;

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

@@ -1,14 +0,0 @@
-import { ModelDefinition } from "../../..";
-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

@@ -1,22 +0,0 @@
-import { RelationsDefinition } from "../../..";
-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

@@ -1,23 +0,0 @@
-import { ModelDefinition } from "../../..";
-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

@@ -1,15 +0,0 @@
-import { RelationsDefinition } from "../../..";
-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

@@ -1,29 +0,0 @@
-import { z } from "zod";
-
-import { ModelDefinition } from "../../..";
-import { sql } from "../../../sql";
-
-export const user = {
-    columns: {
-        id: { type: "uuid", default: sql`uuid_generate_v4()` },
-        username: { zodSchema: z.string(), type: "text" },
-        invitedById: {
-            name: "invited_by_id",
-            type: "uuid",
-            nullable: true,
-            references: { table: "user", column: "id" },
-        },
-        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

@@ -1,38 +0,0 @@
-import { RelationsDefinition } from "../../..";
-import { Models } from "../models";
-
-export const user = {
-    posts: {
-        type: "1:N",
-        model: "post",
-        foreignKey: "authorId",
-    },
-    reviewedPosts: {
-        type: "1:N",
-        model: "post",
-        foreignKey: "reviewedById",
-    },
-    invitedBy: {
-        type: "N:1",
-        model: "user",
-        foreignKey: "invitedById",
-        optional: true,
-    },
-    invitedUsers: {
-        type: "1:N",
-        model: "user",
-        foreignKey: "invitedById",
-    },
-    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

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

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

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

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

package/src/test/gen/model.ts

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

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

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

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

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

@@ -1,19 +0,0 @@
-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();
-    }
-};