@casekit/orm 0.0.1-alpha.8 → 0.0.1-release-candidate

package/build/builders/buildCount.d.ts

@@ -0,0 +1,24 @@
+/**
+ * NB. Lots of ! in this file which maybe isn't great but I think for these
+ * builders, where we can be fairly confident due to the type-checking at the edges
+ * that things are defined, it's better than the alternative of loads of
+ * redundant checks for undefined. We've done all the checks we need at the
+ * stage of normalizing the model, we can now assume everything is wired up
+ * correctly.
+ *
+ * Also this is a file in which there's a lot of mutation and dependency
+ * on the order in which things are done, which is not ideal but is what
+ * it is. Refactor and/or add to/change with care.
+ */
+import { NormalizedConfig } from "@casekit/orm-config";
+import { ModelDefinitions, OperatorDefinitions } from "@casekit/orm-schema";
+import { Middleware } from "../types/Middleware.js";
+import { WhereClause } from "../types/WhereClause.js";
+import { CountBuilder } from "./types.js";
+type BaseCountParams = {
+    where?: WhereClause<ModelDefinitions, OperatorDefinitions, string>;
+    include?: Record<string, BaseCountParams>;
+    for?: "update" | "no key update" | "share" | "key share";
+};
+export declare const buildCount: (config: NormalizedConfig, middleware: Middleware[], modelName: string, query: BaseCountParams, path?: string[], tableIndex?: number) => CountBuilder;
+export {};

package/build/builders/buildCount.js

@@ -0,0 +1,60 @@
+import { makeTableAlias } from "#util/makeTableAlias.js";
+import { buildWhere } from "./buildWhere.js";
+/**
+ * Builds a base CountBuilder, with only columns from the main table.
+ * Joins will be added later.
+ */
+const buildBaseCount = (config, middleware, m, query, tableIndex = 0) => {
+    const model = config.models[m];
+    if (!model)
+        throw new Error(`Model "${m}" not found`);
+    const table = {
+        schema: model.schema,
+        name: model.table,
+        alias: makeTableAlias(tableIndex++),
+        model: m,
+    };
+    const where = buildWhere(config, middleware, table, query.where);
+    return {
+        table,
+        where,
+        joins: [],
+        for: query.for,
+        tableIndex,
+    };
+};
+export const buildCount = (config, middleware, modelName, query, path = [], tableIndex = 0) => {
+    const model = config.models[modelName];
+    if (!model)
+        throw new Error(`Model "${modelName}" not found`);
+    const builder = buildBaseCount(config, middleware, modelName, query, tableIndex);
+    for (const [r, subquery] of Object.entries(query.include ?? {})) {
+        const relation = model.relations[r];
+        if (relation.type !== "N:1") {
+            continue;
+        }
+        const joinBuilder = buildCount(config, middleware, relation.model, subquery, [...path, r], builder.tableIndex);
+        builder.joins.push({
+            path: [...path, r],
+            relation: r,
+            table: joinBuilder.table,
+            where: joinBuilder.where,
+            type: "INNER",
+            columns: relation.from.columns.map((fk, i) => ({
+                from: {
+                    table: builder.table.alias,
+                    name: fk,
+                },
+                to: {
+                    table: joinBuilder.table.alias,
+                    name: relation.to.columns[i],
+                },
+            })),
+        });
+        // update the parent builder's tableIndex with the one from the
+        // joinBuilder, so that we don't have overlapping table indices
+        builder.tableIndex = joinBuilder.tableIndex;
+        builder.joins.push(...joinBuilder.joins);
+    }
+    return builder;
+};

package/build/builders/buildCount.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/builders/buildCount.test.js

@@ -0,0 +1,144 @@
+import { describe, expect, test } from "vitest";
+import { sql } from "@casekit/sql";
+import { createTestDB } from "../tests/util/db.js";
+import { buildCount } from "./buildCount.js";
+describe("buildCount", () => {
+    const { db } = createTestDB();
+    test("builds basic count query", () => {
+        const result = buildCount(db.config, [], "post", {});
+        expect(result).toEqual({
+            table: {
+                schema: "orm",
+                name: "post",
+                alias: "a",
+                model: "post",
+            },
+            where: null,
+            joins: [],
+            for: undefined,
+            tableIndex: 1,
+        });
+    });
+    test("builds count query with N:1 relation include", () => {
+        const result = buildCount(db.config, [], "post", {
+            where: { id: 1 },
+            include: {
+                author: {
+                    where: {},
+                },
+            },
+        });
+        expect(result).toEqual({
+            table: {
+                schema: "orm",
+                name: "post",
+                alias: "a",
+                model: "post",
+            },
+            where: sql `"a"."id" = ${1}`,
+            joins: [
+                {
+                    relation: "author",
+                    table: {
+                        schema: "orm",
+                        name: "user",
+                        alias: "b",
+                        model: "user",
+                    },
+                    where: null,
+                    type: "INNER",
+                    path: ["author"],
+                    columns: [
+                        {
+                            from: { table: "a", name: "author_id" },
+                            to: { table: "b", name: "id" },
+                        },
+                    ],
+                },
+            ],
+            for: undefined,
+            tableIndex: 2,
+        });
+    });
+    test("builds count query with where clause", () => {
+        const result = buildCount(db.config, [], "post", {
+            where: {
+                title: "Test Post",
+            },
+        });
+        expect(result).toEqual({
+            table: {
+                schema: "orm",
+                name: "post",
+                alias: "a",
+                model: "post",
+            },
+            where: sql `"a"."title" = ${"Test Post"}`,
+            joins: [],
+            for: undefined,
+            tableIndex: 1,
+        });
+    });
+    test("builds count query with nested includes and where clauses", () => {
+        const result = buildCount(db.config, [], "post", {
+            where: {
+                title: "Test Post",
+            },
+            include: {
+                author: {
+                    where: {
+                        name: "John",
+                    },
+                },
+            },
+        });
+        expect(result).toEqual({
+            table: {
+                schema: "orm",
+                name: "post",
+                alias: "a",
+                model: "post",
+            },
+            where: sql `"a"."title" = ${"Test Post"}`,
+            joins: [
+                {
+                    relation: "author",
+                    table: {
+                        schema: "orm",
+                        name: "user",
+                        alias: "b",
+                        model: "user",
+                    },
+                    where: sql `"b"."name" = ${"John"}`,
+                    type: "INNER",
+                    path: ["author"],
+                    columns: [
+                        {
+                            from: { table: "a", name: "author_id" },
+                            to: { table: "b", name: "id" },
+                        },
+                    ],
+                },
+            ],
+            for: undefined,
+            tableIndex: 2,
+        });
+    });
+    test("builds count query with for parameter", () => {
+        const result = buildCount(db.config, [], "post", {
+            for: "update",
+        });
+        expect(result).toEqual({
+            table: {
+                schema: "orm",
+                name: "post",
+                alias: "a",
+                model: "post",
+            },
+            where: null,
+            joins: [],
+            for: "update",
+            tableIndex: 1,
+        });
+    });
+});

package/build/builders/buildCreate.d.ts

@@ -0,0 +1,6 @@
+import { NormalizedConfig } from "@casekit/orm-config";
+import { ModelDefinitions, ModelName } from "@casekit/orm-schema";
+import { CreateManyParams } from "#types/CreateManyParams.js";
+import { Middleware } from "../types/Middleware.js";
+import { CreateBuilder } from "./types.js";
+export declare const buildCreate: (config: NormalizedConfig, middleware: Middleware[], modelName: string, query: CreateManyParams<ModelDefinitions, ModelName<ModelDefinitions>>, path?: string[], tableIndex?: number) => CreateBuilder;

package/build/builders/buildCreate.js

@@ -0,0 +1,31 @@
+import { uniq } from "es-toolkit";
+import { makeTableAlias } from "#util/makeTableAlias.js";
+import { applyValuesMiddleware } from "../util/applyValuesMiddleware.js";
+export const buildCreate = (config, middleware, modelName, query, path = [], tableIndex = 0) => {
+    const model = config.models[modelName];
+    if (!model)
+        throw new Error(`Model "${modelName}" not found`);
+    // Apply values middleware to each value object
+    const processedValues = query.values.map((v) => applyValuesMiddleware(config, middleware, modelName, v));
+    const fields = uniq(processedValues.flatMap(Object.keys));
+    const table = {
+        schema: model.schema,
+        name: model.table,
+        alias: makeTableAlias(tableIndex++),
+        model: modelName,
+    };
+    const columns = fields.map((f) => model.fields[f].column);
+    const values = processedValues.map((v) => fields.map((f) => v[f] ?? null));
+    const returning = query.returning?.map((f, index) => ({
+        name: model.fields[f].column,
+        alias: `${table.alias}_${index}`,
+        path: [...path, f],
+    })) ?? [];
+    return {
+        table,
+        columns,
+        values,
+        returning,
+        onConflict: query.onConflict,
+    };
+};

package/build/builders/buildCreate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/builders/buildCreate.test.js

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "vitest";
+import { createTestDB } from "../tests/util/db.js";
+import { buildCreate } from "./buildCreate.js";
+describe("buildCreate", () => {
+    const { db } = createTestDB();
+    test("should build a create query", () => {
+        const result = buildCreate(db.config, [], "user", {
+            values: [{ id: 1, name: "John Doe", email: "john@example.com" }],
+        });
+        expect(result).toEqual({
+            table: {
+                schema: "orm",
+                name: "user",
+                alias: "a",
+                model: "user",
+            },
+            columns: ["id", "name", "email"],
+            values: [[1, "John Doe", "john@example.com"]],
+            returning: [],
+            onConflict: undefined,
+        });
+    });
+    test("should throw an error if model is not found", () => {
+        expect(() => buildCreate(db.config, [], "NonExistentModel", {
+            values: [
+                { id: 1, name: "John Doe", email: "john@example.com" },
+            ],
+        })).toThrow('Model "NonExistentModel" not found');
+    });
+    test("should handle returning fields", () => {
+        const result = buildCreate(db.config, [], "user", {
+            values: [{ id: 1, name: "John Doe", email: "john@example.com" }],
+            returning: ["id", "name"],
+        });
+        expect(result.returning).toEqual([
+            { name: "id", alias: "a_0", path: ["id"] },
+            { name: "name", alias: "a_1", path: ["name"] },
+        ]);
+    });
+    test("should handle onConflict", () => {
+        const result = buildCreate(db.config, [], "user", {
+            values: [{ id: 1, name: "John Doe", email: "john@example.com" }],
+            onConflict: { do: "nothing" },
+        });
+        expect(result.onConflict).toEqual({ do: "nothing" });
+    });
+});

package/build/builders/buildDelete.d.ts

@@ -0,0 +1,6 @@
+import { NormalizedConfig } from "@casekit/orm-config";
+import { ModelDefinitions, ModelName, OperatorDefinitions } from "@casekit/orm-schema";
+import { DeleteParams } from "#types/DeleteParams.js";
+import { Middleware } from "../types/Middleware.js";
+import { DeleteBuilder } from "./types.js";
+export declare const buildDelete: (config: NormalizedConfig, middleware: Middleware[], modelName: string, query: DeleteParams<ModelDefinitions, OperatorDefinitions, ModelName<ModelDefinitions>>, path?: string[], tableIndex?: number) => DeleteBuilder;

package/build/builders/buildDelete.js

@@ -0,0 +1,28 @@
+import { makeTableAlias } from "#util/makeTableAlias.js";
+import { hasClauses } from "../util/hasClauses.js";
+import { buildWhere } from "./buildWhere.js";
+export const buildDelete = (config, middleware, modelName, query, path = [], tableIndex = 0) => {
+    const model = config.models[modelName];
+    if (!model)
+        throw new Error(`Model "${modelName}" not found`);
+    const table = {
+        schema: model.schema,
+        name: model.table,
+        alias: makeTableAlias(tableIndex++),
+        model: modelName,
+    };
+    if (!hasClauses(query.where)) {
+        throw new Error("Delete queries must have a where clause");
+    }
+    const where = buildWhere(config, middleware, table, query.where);
+    const returning = query.returning?.map((f, index) => ({
+        name: model.fields[f].column,
+        alias: `${table.alias}_${index}`,
+        path: [...path, f],
+    })) ?? [];
+    return {
+        table,
+        where,
+        returning,
+    };
+};

package/build/builders/buildDelete.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/builders/buildDelete.test.js

@@ -0,0 +1,108 @@
+import { describe, expect, test } from "vitest";
+import { sql } from "@casekit/sql";
+import { createTestDB } from "../tests/util/db.js";
+import { buildDelete } from "./buildDelete.js";
+describe("buildDelete", () => {
+    const { db } = createTestDB();
+    test("builds basic delete query with where clause", () => {
+        const result = buildDelete(db.config, [], "user", {
+            where: { id: 1 },
+        });
+        expect(result).toEqual({
+            table: {
+                schema: "orm",
+                name: "user",
+                alias: "a",
+                model: "user",
+            },
+            where: sql `"a"."id" = ${1}`,
+            returning: [],
+        });
+    });
+    test("builds delete query with returning clause", () => {
+        const result = buildDelete(db.config, [], "user", {
+            where: { id: 1 },
+            returning: ["id", "name"],
+        });
+        expect(result).toEqual({
+            table: {
+                schema: "orm",
+                name: "user",
+                alias: "a",
+                model: "user",
+            },
+            where: sql `"a"."id" = ${1}`,
+            returning: [
+                {
+                    name: "id",
+                    alias: "a_0",
+                    path: ["id"],
+                },
+                {
+                    name: "name",
+                    alias: "a_1",
+                    path: ["name"],
+                },
+            ],
+        });
+    });
+    test("throws error when model not found", () => {
+        expect(() => buildDelete(db.config, [], "nonexistentModel", {
+            where: { id: 1 },
+        })).toThrow('Model "nonexistentModel" not found');
+    });
+    test("throws error when where clause is empty", () => {
+        expect(() => buildDelete(db.config, [], "user", {
+            where: {},
+        })).toThrow("Delete queries must have a where clause");
+    });
+    test("throws error when where clause is undefined", () => {
+        expect(() => buildDelete(db.config, [], "user", {
+            // @ts-expect-error testing runtime behavior with invalid input
+            where: undefined,
+        })).toThrow("Delete queries must have a where clause");
+    });
+    test("handles complex where clauses", () => {
+        const result = buildDelete(db.config, [], "user", {
+            where: {
+                id: 1,
+                name: "test",
+                email: { $like: "%@example.com" },
+            },
+        });
+        expect(result).toEqual({
+            table: {
+                schema: "orm",
+                name: "user",
+                alias: "a",
+                model: "user",
+            },
+            where: expect.any(Object), // SQL statement object
+            returning: [],
+        });
+    });
+    test("uses correct path for nested fields in returning clause", () => {
+        const result = buildDelete(db.config, [], "user", {
+            where: { id: 1 },
+            returning: ["id", "name"],
+        }, ["parent"]);
+        expect(result.returning).toEqual([
+            {
+                name: "id",
+                alias: "a_0",
+                path: ["parent", "id"],
+            },
+            {
+                name: "name",
+                alias: "a_1",
+                path: ["parent", "name"],
+            },
+        ]);
+    });
+    test("uses provided table index for alias generation", () => {
+        const result = buildDelete(db.config, [], "user", {
+            where: { id: 1 },
+        }, [], 5);
+        expect(result.table.alias).toBe("f");
+    });
+});

package/build/builders/buildFind.d.ts

@@ -0,0 +1,9 @@
+import { NormalizedConfig } from "@casekit/orm-config";
+import { ModelDefinition, OperatorDefinitions } from "@casekit/orm-schema";
+import { FindParams } from "#types/FindParams.js";
+import { Middleware } from "../types/Middleware.js";
+import { FindBuilder } from "./types.js";
+export declare const buildFind: (config: NormalizedConfig, middleware: Middleware[], modelName: string, query: FindParams<Record<string, Required<ModelDefinition>>, OperatorDefinitions, string>, lateralBy?: {
+    field: string;
+    values: unknown[];
+}[], path?: string[], tableIndex?: number) => FindBuilder;