@casekit/orm 0.0.1-alpha.9 → 0.0.1-release-candidate.2

package/build/sql/countToSql.test.js

@@ -0,0 +1,218 @@
+import { describe, expect, test } from "vitest";
+import { sql } from "@casekit/sql";
+import { unindent } from "@casekit/unindent";
+import { countToSql } from "./countToSql.js";
+describe("countToSql", () => {
+    test("generates basic count query", () => {
+        const statement = countToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "a",
+                model: "user",
+            },
+            joins: [],
+            tableIndex: 0,
+        });
+        expect(statement.pretty).toBe(unindent `
+            SELECT
+                count(1) AS "count"
+            FROM
+                "public"."users" AS "a"
+        `);
+    });
+    test("generates count query with where clause", () => {
+        const statement = countToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "a",
+                model: "user",
+            },
+            joins: [],
+            where: sql `"a"."active" = ${true}`,
+            tableIndex: 0,
+        });
+        expect(statement.pretty).toBe(unindent `
+                SELECT
+                    count(1) AS "count"
+                FROM
+                    "public"."users" AS "a"
+                WHERE
+                    "a"."active" = TRUE
+            `);
+    });
+    test("generates count query with single join", () => {
+        const statement = countToSql({
+            table: {
+                schema: "public",
+                name: "posts",
+                alias: "a",
+                model: "post",
+            },
+            joins: [
+                {
+                    type: "INNER",
+                    relation: "author",
+                    table: {
+                        schema: "public",
+                        name: "users",
+                        alias: "b",
+                        model: "user",
+                    },
+                    columns: [
+                        {
+                            from: { table: "a", name: "author_id" },
+                            to: { table: "b", name: "id" },
+                        },
+                    ],
+                    path: ["author"],
+                },
+            ],
+            tableIndex: 0,
+        });
+        expect(statement.pretty).toBe(unindent `
+            SELECT
+                count(1) AS "count"
+            FROM
+                "public"."posts" AS "a"
+                JOIN "public"."users" AS "b" ON "a"."author_id" = "b"."id"
+        `);
+    });
+    test("generates count query with multiple joins", () => {
+        const statement = countToSql({
+            table: {
+                schema: "public",
+                name: "posts",
+                alias: "a",
+                model: "post",
+            },
+            joins: [
+                {
+                    type: "INNER",
+                    relation: "author",
+                    table: {
+                        schema: "public",
+                        name: "users",
+                        alias: "b",
+                        model: "user",
+                    },
+                    columns: [
+                        {
+                            from: { table: "a", name: "author_id" },
+                            to: { table: "b", name: "id" },
+                        },
+                    ],
+                    path: ["author"],
+                },
+                {
+                    type: "INNER",
+                    relation: "category",
+                    table: {
+                        schema: "public",
+                        name: "categories",
+                        alias: "c",
+                        model: "category",
+                    },
+                    columns: [
+                        {
+                            from: { table: "a", name: "category_id" },
+                            to: { table: "c", name: "id" },
+                        },
+                    ],
+                    path: ["category"],
+                },
+            ],
+            tableIndex: 0,
+        });
+        expect(statement.pretty).toBe(unindent `
+            SELECT
+                count(1) AS "count"
+            FROM
+                "public"."posts" AS "a"
+                JOIN "public"."users" AS "b" ON "a"."author_id" = "b"."id"
+                JOIN "public"."categories" AS "c" ON "a"."category_id" = "c"."id"
+        `);
+    });
+    test("generates count query with multiple joins and where clause", () => {
+        const statement = countToSql({
+            table: {
+                schema: "public",
+                name: "posts",
+                alias: "a",
+                model: "post",
+            },
+            joins: [
+                {
+                    type: "INNER",
+                    relation: "author",
+                    table: {
+                        schema: "public",
+                        name: "users",
+                        alias: "b",
+                        model: "user",
+                    },
+                    where: sql `"b"."id" = ${123}`,
+                    columns: [
+                        {
+                            from: { table: "a", name: "author_id" },
+                            to: { table: "b", name: "id" },
+                        },
+                    ],
+                    path: ["author"],
+                },
+                {
+                    type: "INNER",
+                    relation: "category",
+                    table: {
+                        schema: "public",
+                        name: "categories",
+                        alias: "c",
+                        model: "category",
+                    },
+                    columns: [
+                        {
+                            from: { table: "a", name: "category_id" },
+                            to: { table: "c", name: "id" },
+                        },
+                    ],
+                    path: ["category"],
+                },
+            ],
+            where: sql `"a"."published" = ${true} AND "b"."active" = ${true}`,
+            tableIndex: 0,
+        });
+        expect(statement.pretty).toBe(unindent `
+            SELECT
+                count(1) AS "count"
+            FROM
+                "public"."posts" AS "a"
+                JOIN "public"."users" AS "b" ON "a"."author_id" = "b"."id"
+                AND "b"."id" = $1
+                JOIN "public"."categories" AS "c" ON "a"."category_id" = "c"."id"
+            WHERE
+                "a"."published" = TRUE
+                AND "b"."active" = TRUE
+        `);
+        expect(statement.values).toEqual([123]);
+    });
+    test("generates count query with FOR clause", () => {
+        const statement = countToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "a",
+                model: "user",
+            },
+            joins: [],
+            for: "update",
+            tableIndex: 0,
+        });
+        expect(statement.pretty).toBe(unindent `
+            SELECT
+                count(1) AS "count"
+            FROM
+                "public"."users" AS "a"
+        `);
+    });
+});

package/build/sql/createToSql.d.ts

@@ -0,0 +1,3 @@
+import { SQLStatement } from "@casekit/sql";
+import { CreateBuilder } from "#builders/types.js";
+export declare const createToSql: (builder: CreateBuilder) => SQLStatement;

package/build/sql/createToSql.js

@@ -0,0 +1,27 @@
+import { sql } from "@casekit/sql";
+import { returnedColumn, tableName } from "./util.js";
+export const createToSql = (builder) => {
+    const { table, columns, values, onConflict, returning } = builder;
+    const statement = columns.length > 0
+        ? sql `
+                INSERT INTO ${tableName(table)}
+                (${columns.map(sql.ident)})
+                VALUES
+                ${values.map((vs) => sql `(${vs.map(sql.value)})`)}
+            `
+        : sql `
+                INSERT INTO ${tableName(table)}
+                DEFAULT VALUES
+            `;
+    if (onConflict?.do === "nothing") {
+        statement.append `
+            ON CONFLICT DO NOTHING
+        `;
+    }
+    if (returning.length > 0) {
+        statement.append `
+            RETURNING ${sql.join(returning.map(returnedColumn))}
+        `;
+    }
+    return statement;
+};

package/build/sql/createToSql.test.d.ts

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

package/build/sql/createToSql.test.js

@@ -0,0 +1,186 @@
+import { describe, expect, test } from "vitest";
+import { unindent } from "@casekit/unindent";
+import { createToSql } from "./createToSql.js";
+describe("createToSql", () => {
+    test("basic insert with columns and values", () => {
+        const result = createToSql({
+            table: { schema: "orm", name: "users", alias: "u", model: "user" },
+            columns: ["name", "email"],
+            values: [["John", "john@example.com"]],
+            returning: [],
+        });
+        expect(result.pretty).toBe(unindent `            
+            INSERT INTO
+                "orm"."users" AS "u" ("name", "email")
+            VALUES
+                ($1, $2)
+        `);
+        expect(result.values).toEqual(["John", "john@example.com"]);
+    });
+    test("insert with DEFAULT VALUES", () => {
+        const result = createToSql({
+            table: { schema: "orm", name: "users", alias: "u", model: "user" },
+            columns: [],
+            values: [],
+            returning: [],
+        });
+        expect(result.pretty).toBe(unindent `
+            INSERT INTO
+                "orm"."users" AS "u"
+            DEFAULT VALUES
+        `);
+        expect(result.values).toEqual([]);
+    });
+    test("insert with ON CONFLICT DO NOTHING", () => {
+        const result = createToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "u",
+                model: "user",
+            },
+            columns: ["name"],
+            values: [["John"]],
+            returning: [],
+            onConflict: { do: "nothing" },
+        });
+        expect(result.pretty).toBe(unindent `
+            INSERT INTO
+                "public"."users" AS "u" ("name")
+            VALUES
+                ($1)
+            ON CONFLICT DO NOTHING
+        `);
+        expect(result.values).toEqual(["John"]);
+    });
+    test("insert with RETURNING clause", () => {
+        const result = createToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "u",
+                model: "user",
+            },
+            columns: ["name"],
+            values: [["John"]],
+            returning: [{ name: "id", alias: "u_0", path: ["id"] }],
+        });
+        expect(result.pretty).toBe(unindent `
+            INSERT INTO
+                "public"."users" AS "u" ("name")
+            VALUES
+                ($1)
+            RETURNING
+                "id" AS "u_0"
+        `);
+        expect(result.values).toEqual(["John"]);
+    });
+    test("insert multiple rows with multiple returned fields", () => {
+        const result = createToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "u",
+                model: "user",
+            },
+            columns: ["name", "email", "age"],
+            values: [
+                ["John", "john@example.com", 25],
+                ["Jane", "jane@example.com", 30],
+                ["Bob", "bob@example.com", 35],
+            ],
+            returning: [
+                { name: "id", alias: "u_0", path: ["id"] },
+                { name: "created_at", alias: "u_1", path: ["created_at"] },
+                { name: "email", alias: "u_2", path: ["email"] },
+            ],
+        });
+        expect(result.pretty).toBe(unindent `
+            INSERT INTO
+                "public"."users" AS "u" ("name", "email", "age")
+            VALUES
+                ($1, $2, $3),
+                ($4, $5, $6),
+                ($7, $8, $9)
+            RETURNING
+                "id" AS "u_0",
+                "created_at" AS "u_1",
+                "email" AS "u_2"
+        `);
+        expect(result.values).toEqual([
+            "John",
+            "john@example.com",
+            25,
+            "Jane",
+            "jane@example.com",
+            30,
+            "Bob",
+            "bob@example.com",
+            35,
+        ]);
+    });
+    test("insert array values", () => {
+        const result = createToSql({
+            table: {
+                schema: "public",
+                name: "posts",
+                alias: "p",
+                model: "post",
+            },
+            columns: ["title", "content", "tags"],
+            values: [
+                ["My first post", "Hello, world!", ["hello", "world"]],
+                ["My second post", "Goodbye, world!", ["goodbye", "world"]],
+            ],
+            returning: [
+                { name: "id", alias: "p_0", path: ["id"] },
+                { name: "tags", alias: "p_1", path: ["tags"] },
+            ],
+        });
+        expect(result.pretty).toBe(unindent `
+            INSERT INTO
+                "public"."posts" AS "p" ("title", "content", "tags")
+            VALUES
+                ($1, $2, $3),
+                ($4, $5, $6)
+            RETURNING
+                "id" AS "p_0",
+                "tags" AS "p_1"
+        `);
+        expect(result.values).toEqual([
+            "My first post",
+            "Hello, world!",
+            ["hello", "world"],
+            "My second post",
+            "Goodbye, world!",
+            ["goodbye", "world"],
+        ]);
+    });
+    test("insert with ON CONFLICT DO NOTHING and RETURNING with DEFAULT VALUES", () => {
+        const result = createToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "u",
+                model: "user",
+            },
+            columns: [],
+            values: [],
+            returning: [
+                { name: "id", alias: "u_0", path: ["id"] },
+                { name: "created_at", alias: "u_1", path: ["created_at"] },
+            ],
+            onConflict: { do: "nothing" },
+        });
+        expect(result.pretty).toBe(unindent `
+            INSERT INTO
+                "public"."users" AS "u"
+            DEFAULT VALUES
+            ON CONFLICT DO NOTHING
+            RETURNING
+                "id" AS "u_0",
+                "created_at" AS "u_1"
+        `);
+        expect(result.values).toEqual([]);
+    });
+});

package/build/sql/deleteToSql.d.ts

@@ -0,0 +1,3 @@
+import { SQLStatement } from "@casekit/sql";
+import { DeleteBuilder } from "#builders/types.js";
+export declare const deleteToSql: (builder: DeleteBuilder) => SQLStatement;

package/build/sql/deleteToSql.js

@@ -0,0 +1,15 @@
+import { sql } from "@casekit/sql";
+import { returnedColumn, tableName } from "./util.js";
+export const deleteToSql = (builder) => {
+    const { table, where, returning } = builder;
+    const statement = sql `
+        DELETE FROM ${tableName(table)}
+        WHERE ${where}
+    `;
+    if (returning.length > 0) {
+        statement.append `
+            RETURNING ${sql.join(returning.map(returnedColumn))}
+        `;
+    }
+    return statement;
+};

package/build/sql/deleteToSql.test.d.ts

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

package/build/sql/deleteToSql.test.js

@@ -0,0 +1,93 @@
+import { describe, expect, test } from "vitest";
+import { sql } from "@casekit/sql";
+import { unindent } from "@casekit/unindent";
+import { deleteToSql } from "./deleteToSql.js";
+describe("deleteToSql", () => {
+    test("generates basic delete query", () => {
+        const statement = deleteToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "u",
+                model: "user",
+            },
+            where: sql `id = 1`,
+            returning: [],
+        });
+        expect(statement.pretty).toBe(unindent `
+            DELETE FROM "public"."users" AS "u"
+            WHERE
+                id = 1
+       `);
+        expect(statement.values).toEqual([]);
+    });
+    test("generates query with returning clause", () => {
+        const statement = deleteToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "u",
+                model: "user",
+            },
+            where: sql `id = 1`,
+            returning: [
+                { name: "id", alias: "u_0", path: ["id"] },
+                { name: "name", alias: "u_1", path: ["name"] },
+            ],
+        });
+        expect(statement.pretty).toBe(unindent `
+            DELETE FROM "public"."users" AS "u"
+            WHERE
+                id = 1
+            RETURNING
+                "id" AS "u_0",
+                "name" AS "u_1"
+        `);
+        expect(statement.values).toEqual([]);
+    });
+    test("handles complex where clause", () => {
+        const statement = deleteToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "u",
+                model: "user",
+            },
+            where: sql `id = ${1} AND email LIKE ${"@example.com"}`,
+            returning: [],
+        });
+        expect(statement.pretty).toBe(unindent `
+            DELETE FROM "public"."users" AS "u"
+            WHERE
+                id = $1
+                AND email LIKE $2
+        `);
+        expect(statement.values).toEqual([1, "@example.com"]);
+    });
+    test("handles multiple returning columns", () => {
+        const statement = deleteToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "u",
+                model: "user",
+            },
+            where: sql `id = 1`,
+            returning: [
+                { name: "id", alias: "u_0", path: ["id"] },
+                { name: "name", alias: "u_1", path: ["name"] },
+                { name: "email", alias: "u_2", path: ["email"] },
+            ],
+        });
+        expect(statement.pretty).toBe(unindent `
+            DELETE FROM "public"."users" AS "u"
+            WHERE
+                id = 1
+            RETURNING
+                "id" AS "u_0",
+                "name" AS "u_1",
+                "email" AS "u_2"
+        `);
+        expect(statement.values).toEqual([]);
+    });
+});

package/build/sql/findToSql.d.ts

@@ -0,0 +1,3 @@
+import { SQLStatement } from "@casekit/sql";
+import { FindBuilder } from "#builders/types.js";
+export declare const findToSql: (builder: FindBuilder) => SQLStatement;

package/build/sql/findToSql.js

@@ -0,0 +1,33 @@
+import { sql } from "@casekit/sql";
+import { joinClause, orderByColumn, selectColumn, tableName, unnestPk, } from "./util.js";
+export const findToSql = (builder) => {
+    const { table, columns, joins, lateralBy, where, orderBy, limit, offset } = builder;
+    if (lateralBy) {
+        const { primaryKeys, outerAlias, innerAlias } = lateralBy;
+        return sql `
+            SELECT ${sql.ident(outerAlias)}.*
+            FROM (SELECT ${sql.join(primaryKeys.map(unnestPk))}) AS ${sql.ident(innerAlias)}
+            JOIN LATERAL (
+                SELECT ${sql.join(columns.map(selectColumn))}
+                FROM ${tableName(table)}
+                ${sql.join(joins.map(joinClause), "\n")}
+                WHERE (${where ?? sql `1 = 1`})
+                AND (${sql.join(primaryKeys.map(({ column }) => sql `${sql.ident(innerAlias)}.${sql.ident(column)} = ${sql.ident(table.alias)}.${sql.ident(column)}`), " AND ")})
+                ${orderBy.length > 0 ? sql `ORDER BY ${sql.join(orderBy.map(orderByColumn), ", ")}` : sql ``}
+                ${limit ? sql `LIMIT ${limit}` : sql ``}
+                ${offset ? sql `OFFSET ${offset}` : sql ``}
+            ) ${sql.ident(outerAlias)} ON TRUE
+        `;
+    }
+    else {
+        return sql `
+            SELECT ${sql.join(columns.map(selectColumn))}
+            FROM ${tableName(table)}
+            ${sql.join(joins.map(joinClause), "\n")}
+            ${where ? sql `WHERE ${where}\n` : sql ``}
+            ${orderBy.length > 0 ? sql `ORDER BY ${sql.join(orderBy.map(orderByColumn), ", ")}` : sql ``}
+            ${limit ? sql `LIMIT ${limit}` : sql ``}
+            ${offset ? sql `OFFSET ${offset}` : sql ``}
+        `;
+    }
+};

package/build/sql/findToSql.test.d.ts

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