@casekit/orm2 0.0.0-20250322230249

package/build/sql/findToSql.test.js

@@ -0,0 +1,409 @@
+import { describe, expect, test } from "vitest";
+import { sql } from "@casekit/sql";
+import { unindent } from "@casekit/unindent";
+import { findToSql } from "./findToSql.js";
+describe("findToSql", () => {
+    test("generates basic select query", () => {
+        const statement = findToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "a",
+                model: "user",
+            },
+            columns: [
+                { table: "a", name: "id", alias: "a_0", path: ["id"] },
+                { table: "a", name: "name", alias: "a_1", path: ["name"] },
+            ],
+            joins: [],
+            orderBy: [],
+            tableIndex: 0,
+        });
+        expect(statement.pretty).toBe(unindent `
+            SELECT
+                "a"."id" AS "a_0",
+                "a"."name" AS "a_1"
+            FROM
+                "public"."users" AS "a"
+        `);
+    });
+    test("generates query with joins", () => {
+        const statement = findToSql({
+            table: {
+                schema: "public",
+                name: "posts",
+                alias: "a",
+                model: "post",
+            },
+            columns: [
+                { table: "a", name: "id", alias: "a_0", path: ["id"] },
+                {
+                    table: "b",
+                    name: "name",
+                    alias: "b_0",
+                    path: ["author", "name"],
+                },
+            ],
+            joins: [
+                {
+                    type: "LEFT",
+                    path: ["author"],
+                    relation: "author",
+                    table: {
+                        schema: "public",
+                        name: "users",
+                        alias: "b",
+                        model: "user",
+                    },
+                    columns: [
+                        {
+                            from: { table: "a", name: "author_id" },
+                            to: { table: "b", name: "id" },
+                        },
+                    ],
+                    where: sql `"b"."deleted_at" IS NULL`,
+                },
+            ],
+            orderBy: [],
+            tableIndex: 0,
+        });
+        expect(statement.pretty).toBe(unindent `
+            SELECT
+                "a"."id" AS "a_0",
+                "b"."name" AS "b_0"
+            FROM
+                "public"."posts" AS "a"
+                LEFT JOIN "public"."users" AS "b" ON "a"."author_id" = "b"."id"
+                AND "b"."deleted_at" IS NULL
+        `);
+    });
+    test("generates query with compound key join", () => {
+        const statement = findToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "a",
+                model: "user",
+            },
+            columns: [
+                { table: "a", name: "id", alias: "a_0", path: ["id"] },
+                {
+                    table: "b",
+                    name: "name",
+                    alias: "b_0",
+                    path: ["organization", "name"],
+                },
+            ],
+            joins: [
+                {
+                    path: ["organization"],
+                    type: "LEFT",
+                    relation: "organization",
+                    table: {
+                        schema: "public",
+                        name: "organisatations",
+                        alias: "b",
+                        model: "organization",
+                    },
+                    columns: [
+                        {
+                            from: { table: "a", name: "org_id" },
+                            to: { table: "b", name: "id" },
+                        },
+                        {
+                            from: { table: "a", name: "org_type" },
+                            to: { table: "b", name: "type" },
+                        },
+                    ],
+                },
+            ],
+            orderBy: [],
+            tableIndex: 0,
+        });
+        expect(statement.pretty).toBe(unindent `
+            SELECT
+                "a"."id" AS "a_0",
+                "b"."name" AS "b_0"
+            FROM
+                "public"."users" AS "a"
+                LEFT JOIN "public"."organisatations" AS "b" ON "a"."org_id" = "b"."id"
+                AND "a"."org_type" = "b"."type"
+        `);
+    });
+    test("generates query with order by", () => {
+        const statement = findToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "a",
+                model: "user",
+            },
+            columns: [{ table: "a", name: "id", alias: "a_0", path: ["id"] }],
+            joins: [],
+            orderBy: [
+                {
+                    column: {
+                        table: "a",
+                        name: "id",
+                    },
+                    direction: "ASC",
+                },
+            ],
+            tableIndex: 0,
+        });
+        expect(statement.pretty).toBe(unindent `
+            SELECT
+                "a"."id" AS "a_0"
+            FROM
+                "public"."users" AS "a"
+            ORDER BY
+                "a"."id" ASC
+        `);
+    });
+    test("generates query with limit and offset", () => {
+        const statement = findToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "a",
+                model: "user",
+            },
+            columns: [{ table: "a", name: "id", alias: "a_0", path: ["id"] }],
+            joins: [],
+            orderBy: [],
+            limit: 10,
+            offset: 20,
+            tableIndex: 0,
+        });
+        expect(statement.pretty).toBe(unindent `
+            SELECT
+                "a"."id" AS "a_0"
+            FROM
+                "public"."users" AS "a"
+            LIMIT
+                $1
+            OFFSET
+                $2
+        `);
+    });
+    test("generates basic select query with lateral", () => {
+        const statement = findToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "a",
+                model: "user",
+            },
+            columns: [
+                { table: "a", name: "id", alias: "a_0", path: ["id"] },
+                { table: "a", name: "name", alias: "a_1", path: ["name"] },
+            ],
+            joins: [],
+            orderBy: [],
+            lateralBy: {
+                outerAlias: "b",
+                innerAlias: "c",
+                primaryKeys: [
+                    {
+                        column: "id",
+                        type: "int",
+                        values: [1, 2, 3],
+                    },
+                ],
+            },
+            tableIndex: 0,
+        });
+        expect(statement.pretty).toBe(unindent `
+            SELECT
+                "b".*
+            FROM
+                (
+                    SELECT
+                        UNNEST(ARRAY[$1::int, $2::int, $3::int]) AS "id"
+                ) AS "c"
+                JOIN LATERAL (
+                    SELECT
+                        "a"."id" AS "a_0",
+                        "a"."name" AS "a_1"
+                    FROM
+                        "public"."users" AS "a"
+                    WHERE
+                        (1 = 1)
+                        AND ("c"."id" = "a"."id")
+                ) "b" ON TRUE
+        `);
+    });
+    test("generates query with joins and lateral", () => {
+        const statement = findToSql({
+            table: {
+                schema: "public",
+                name: "posts",
+                alias: "a",
+                model: "post",
+            },
+            columns: [
+                { table: "a", name: "id", alias: "a_0", path: ["id"] },
+                {
+                    table: "b",
+                    name: "name",
+                    alias: "b_0",
+                    path: ["author", "name"],
+                },
+            ],
+            joins: [
+                {
+                    type: "LEFT",
+                    relation: "author",
+                    path: ["author"],
+                    table: {
+                        schema: "public",
+                        name: "users",
+                        alias: "b",
+                        model: "user",
+                    },
+                    columns: [
+                        {
+                            from: { table: "a", name: "author_id" },
+                            to: { table: "b", name: "id" },
+                        },
+                    ],
+                },
+            ],
+            orderBy: [],
+            lateralBy: {
+                outerAlias: "c",
+                innerAlias: "d",
+                primaryKeys: [
+                    {
+                        column: "id",
+                        type: "int",
+                        values: [1, 2, 3],
+                    },
+                ],
+            },
+            tableIndex: 0,
+        });
+        expect(statement.pretty).toBe(unindent `
+            SELECT
+                "c".*
+            FROM
+                (
+                    SELECT
+                        UNNEST(ARRAY[$1::int, $2::int, $3::int]) AS "id"
+                ) AS "d"
+                JOIN LATERAL (
+                    SELECT
+                        "a"."id" AS "a_0",
+                        "b"."name" AS "b_0"
+                    FROM
+                        "public"."posts" AS "a"
+                        LEFT JOIN "public"."users" AS "b" ON "a"."author_id" = "b"."id"
+                    WHERE
+                        (1 = 1)
+                        AND ("d"."id" = "a"."id")
+                ) "c" ON TRUE
+        `);
+    });
+    test("generates query with order by and lateral", () => {
+        const statement = findToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "a",
+                model: "user",
+            },
+            columns: [{ table: "a", name: "id", alias: "a_0", path: ["id"] }],
+            joins: [],
+            orderBy: [
+                {
+                    column: {
+                        table: "a",
+                        name: "id",
+                    },
+                    direction: "ASC",
+                },
+            ],
+            tableIndex: 0,
+            lateralBy: {
+                outerAlias: "b",
+                innerAlias: "c",
+                primaryKeys: [
+                    {
+                        column: "id",
+                        type: "int",
+                        values: [1, 2, 3],
+                    },
+                ],
+            },
+        });
+        expect(statement.pretty).toBe(unindent `
+            SELECT
+                "b".*
+            FROM
+                (
+                    SELECT
+                        UNNEST(ARRAY[$1::int, $2::int, $3::int]) AS "id"
+                ) AS "c"
+                JOIN LATERAL (
+                    SELECT
+                        "a"."id" AS "a_0"
+                    FROM
+                        "public"."users" AS "a"
+                    WHERE
+                        (1 = 1)
+                        AND ("c"."id" = "a"."id")
+                    ORDER BY
+                        "a"."id" ASC
+                ) "b" ON TRUE
+        `);
+    });
+    test("generates query with limit, offset and lateral", () => {
+        const statement = findToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "a",
+                model: "user",
+            },
+            columns: [{ table: "a", name: "id", alias: "a_0", path: ["id"] }],
+            joins: [],
+            orderBy: [],
+            limit: 10,
+            offset: 20,
+            lateralBy: {
+                outerAlias: "b",
+                innerAlias: "c",
+                primaryKeys: [
+                    {
+                        column: "id",
+                        type: "int",
+                        values: [1, 2, 3],
+                    },
+                ],
+            },
+            tableIndex: 0,
+        });
+        expect(statement.pretty).toBe(unindent `
+            SELECT
+                "b".*
+            FROM
+                (
+                    SELECT
+                        UNNEST(ARRAY[$1::int, $2::int, $3::int]) AS "id"
+                ) AS "c"
+                JOIN LATERAL (
+                    SELECT
+                        "a"."id" AS "a_0"
+                    FROM
+                        "public"."users" AS "a"
+                    WHERE
+                        (1 = 1)
+                        AND ("c"."id" = "a"."id")
+                    LIMIT
+                        $4
+                    OFFSET
+                        $5
+                ) "b" ON TRUE
+        `);
+    });
+});

package/build/sql/updateToSql.d.ts

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

package/build/sql/updateToSql.js

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

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

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

package/build/sql/updateToSql.test.js

@@ -0,0 +1,165 @@
+import { describe, expect, test } from "vitest";
+import { sql } from "@casekit/sql";
+import { unindent } from "@casekit/unindent";
+import { updateToSql } from "./updateToSql.js";
+describe("updateToSql", () => {
+    test("generates basic update query", () => {
+        const statement = updateToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "u",
+                model: "user",
+            },
+            set: [
+                ["name", "John"],
+                ["email", "john@example.com"],
+            ],
+            where: sql `id = 1`,
+            returning: [],
+        });
+        expect(statement.pretty).toBe(unindent `
+            UPDATE "public"."users" AS "u"
+            SET
+                "name" = $1,
+                "email" = $2
+            WHERE
+                id = 1
+        `);
+        expect(statement.values).toEqual(["John", "john@example.com"]);
+    });
+    test("can update array fields", () => {
+        const statement = updateToSql({
+            table: {
+                schema: "public",
+                name: "posts",
+                alias: "p",
+                model: "post",
+            },
+            set: [
+                ["title", "My first post"],
+                ["content", "Hello, world!"],
+                ["tags", ["hello", "world"]],
+            ],
+            returning: [
+                { name: "id", alias: "p_0", path: ["id"] },
+                { name: "tags", alias: "p_1", path: ["tags"] },
+            ],
+            where: sql `id = 1`,
+        });
+        expect(statement.pretty).toBe(unindent `
+            UPDATE "public"."posts" AS "p"
+            SET
+                "title" = $1,
+                "content" = $2,
+                "tags" = $3
+            WHERE
+                id = 1
+            RETURNING
+                "id" AS "p_0",
+                "tags" AS "p_1"
+      `);
+        expect(statement.values).toEqual([
+            "My first post",
+            "Hello, world!",
+            ["hello", "world"],
+        ]);
+    });
+    test("generates query with returning clause", () => {
+        const statement = updateToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "u",
+                model: "user",
+            },
+            set: [["name", "John"]],
+            where: sql `id = 1`,
+            returning: [
+                { name: "id", alias: "u_0", path: ["id"] },
+                { name: "name", alias: "u_1", path: ["name"] },
+            ],
+        });
+        expect(statement.pretty).toBe(unindent `
+            UPDATE "public"."users" AS "u"
+            SET
+                "name" = $1
+            WHERE
+                id = 1
+            RETURNING
+                "id" AS "u_0",
+                "name" AS "u_1"
+        `);
+        expect(statement.values).toEqual(["John"]);
+    });
+    test("handles multiple set clauses", () => {
+        const statement = updateToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "u",
+                model: "user",
+            },
+            set: [
+                ["first_name", "John"],
+                ["last_name", "Doe"],
+                ["email", "john@example.com"],
+            ],
+            where: sql `id = 1`,
+            returning: [],
+        });
+        expect(statement.pretty).toBe(unindent `
+            UPDATE "public"."users" AS "u"
+            SET
+                "first_name" = $1,
+                "last_name" = $2,
+                "email" = $3
+            WHERE
+                id = 1
+        `);
+        expect(statement.values).toEqual(["John", "Doe", "john@example.com"]);
+    });
+    test("handles complex where clause", () => {
+        const statement = updateToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "u",
+                model: "user",
+            },
+            set: [["name", "John"]],
+            where: sql `id = ${1} AND email LIKE ${"@example.com"}`,
+            returning: [],
+        });
+        expect(statement.pretty).toBe(unindent `
+            UPDATE "public"."users" AS "u"
+            SET
+                "name" = $1
+            WHERE
+                id = $2
+                AND email LIKE $3
+        `);
+        expect(statement.values).toEqual(["John", 1, "@example.com"]);
+    });
+    test("handles null values", () => {
+        const statement = updateToSql({
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "u",
+                model: "user",
+            },
+            set: [["deleted_at", null]],
+            where: sql `id = 1`,
+            returning: [],
+        });
+        expect(statement.pretty).toBe(unindent `
+            UPDATE "public"."users" AS "u"
+            SET
+                "deleted_at" = NULL
+            WHERE
+                id = 1
+        `);
+        expect(statement.values).toEqual([]);
+    });
+});

package/build/sql/util.d.ts

@@ -0,0 +1,11 @@
+import { SQLStatement } from "@casekit/sql";
+import { Column, Join, LateralJoin, OrderBy, ReturnedColumn, SelectedColumn, Table } from "#builders/types.js";
+export declare const tableName: (table: Table) => SQLStatement<import("pg").QueryResultRow>;
+export declare const columnName: (column: Column) => SQLStatement<import("pg").QueryResultRow>;
+export declare const selectColumn: ({ table, name, alias }: SelectedColumn) => SQLStatement<import("pg").QueryResultRow>;
+export declare const returnedColumn: ({ name, alias }: ReturnedColumn) => SQLStatement<import("pg").QueryResultRow>;
+export declare const sqlValue: (type: string) => (value: unknown) => SQLStatement<import("pg").QueryResultRow>;
+export declare const unnestPk: (pk: LateralJoin["primaryKeys"][number]) => SQLStatement<import("pg").QueryResultRow>;
+export declare const setClause: ([column, value]: [string, unknown]) => SQLStatement<import("pg").QueryResultRow>;
+export declare const joinClause: (join: Join) => SQLStatement<import("pg").QueryResultRow>;
+export declare const orderByColumn: (orderByColumn: OrderBy) => SQLStatement<import("pg").QueryResultRow>;

package/build/sql/util.js

@@ -0,0 +1,36 @@
+import { SQLStatement, sql } from "@casekit/sql";
+export const tableName = (table) => {
+    return sql `${sql.ident(table.schema)}.${sql.ident(table.name)} AS ${sql.ident(table.alias)}`;
+};
+export const columnName = (column) => {
+    return sql `${sql.ident(column.table)}.${sql.ident(column.name)}`;
+};
+export const selectColumn = ({ table, name, alias }) => {
+    return sql `${sql.ident(table)}.${sql.ident(name)} AS ${sql.ident(alias)}`;
+};
+export const returnedColumn = ({ name, alias }) => {
+    return sql `${sql.ident(name)} AS ${sql.ident(alias)}`;
+};
+export const sqlValue = (type) => (value) => {
+    return sql `${value}::${new SQLStatement(type)}`;
+};
+export const unnestPk = (pk) => {
+    return sql `UNNEST(ARRAY[${sql.join(pk.values.map(sqlValue(pk.type)))}]) AS ${sql.ident(pk.column)}`;
+};
+export const setClause = ([column, value]) => {
+    return sql `${sql.ident(column)} = ${sql.value(value)}`;
+};
+export const joinClause = (join) => {
+    const pkClauses = join.columns.map(({ from, to }) => sql `${columnName(from)} = ${columnName(to)}`);
+    const clauses = join.where ? [...pkClauses, join.where] : pkClauses;
+    return sql `
+        ${join.type === "LEFT" ? sql `LEFT JOIN` : sql `JOIN`}
+        ${tableName(join.table)} ON ${sql.join(clauses, " AND ")}
+    `;
+};
+export const orderByColumn = (orderByColumn) => {
+    return sql `
+        ${columnName(orderByColumn.column)}
+        ${orderByColumn.direction === "ASC" ? sql `ASC` : sql `DESC`}
+    `;
+};

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

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