@casekit/orm2 1.0.1 → 1.0.2

package/build/builders/buildFind.js

@@ -131,29 +131,83 @@ export const buildFind = (config, middleware, modelName, query, lateralBy = [],
             throw new Error(`Unexpected relation type: ${relation.type}. Should be N:1`);
         }
         const joinBuilder = buildFind(config, middleware, relation.model, subquery, [], [...path, r], builder.tableIndex);
-        builder.joins.push({
-            relation: r,
-            path: [...path, r],
-            type: relation.optional && !subquery.where ? "LEFT" : "INNER",
-            table: joinBuilder.table,
-            where: joinBuilder.where,
-            orderBy: joinBuilder.orderBy,
-            columns: relation.from.columns.map((fk, i) => ({
-                from: {
-                    table: builder.table.alias,
-                    name: fk,
-                },
-                to: {
-                    table: joinBuilder.table.alias,
-                    name: relation.to.columns[i],
+        const joinType = relation.optional && !subquery.where ? "LEFT" : "INNER";
+        const needsSubquery = joinType === "LEFT" && joinBuilder.joins.length > 0;
+        if (needsSubquery) {
+            // When we have a LEFT JOIN with nested joins, we need to wrap
+            // everything in a subquery to preserve LEFT JOIN semantics.
+            // Otherwise, INNER JOINs in the nested relations would filter
+            // out rows where the optional relation is NULL.
+            const subqueryAlias = `${joinBuilder.table.alias}_subq`;
+            // The join columns need to reference the subquery output columns
+            // by their aliases rather than the original table
+            const joinColumns = relation.from.columns.map((fk, i) => {
+                const toColumnName = relation.to.columns[i];
+                // Find the column in the subquery that matches the join key
+                const toColumn = joinBuilder.columns.find(col => col.table === joinBuilder.table.alias &&
+                    col.name === toColumnName);
+                if (!toColumn) {
+                    throw new Error(`Join key column ${toColumnName} not found in select for relation ${r}`);
+                }
+                return {
+                    from: {
+                        table: builder.table.alias,
+                        name: fk,
+                    },
+                    to: {
+                        table: subqueryAlias,
+                        name: toColumn.alias, // Use the column alias from subquery
+                    },
+                };
+            });
+            builder.joins.push({
+                relation: r,
+                path: [...path, r],
+                type: joinType,
+                table: joinBuilder.table,
+                where: joinBuilder.where,
+                orderBy: joinBuilder.orderBy,
+                columns: joinColumns,
+                subquery: {
+                    alias: subqueryAlias,
+                    joins: joinBuilder.joins,
+                    columns: joinBuilder.columns,
                 },
-            })),
-        });
+            });
+            // Add columns but update their table reference to the subquery alias
+            // and use the column's alias as the name since that's what the subquery outputs
+            builder.columns.push(...joinBuilder.columns.map(col => ({
+                ...col,
+                table: subqueryAlias,
+                name: col.alias, // The subquery outputs columns with their aliases
+            })));
+        }
+        else {
+            // Original flattening logic for INNER joins or LEFT joins without nesting
+            builder.joins.push({
+                relation: r,
+                path: [...path, r],
+                type: joinType,
+                table: joinBuilder.table,
+                where: joinBuilder.where,
+                orderBy: joinBuilder.orderBy,
+                columns: relation.from.columns.map((fk, i) => ({
+                    from: {
+                        table: builder.table.alias,
+                        name: fk,
+                    },
+                    to: {
+                        table: joinBuilder.table.alias,
+                        name: relation.to.columns[i],
+                    },
+                })),
+            });
+            builder.columns.push(...joinBuilder.columns);
+            builder.joins.push(...joinBuilder.joins);
+        }
         // 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.columns.push(...joinBuilder.columns);
-        builder.joins.push(...joinBuilder.joins);
         // this is admittedly a bit weird,
         // we wouldn't expect N:1 relations to specify
         // ordering, skipping, and limiting, and typescript

package/build/builders/buildFind.test.js

@@ -260,4 +260,33 @@ describe("buildFind", () => {
             },
         ]);
     });
+    test("uses subquery for nested relations when parent relation is optional", () => {
+        const { db } = createTestDB();
+        const result = buildFind(db.config, [], "task", {
+            select: ["id", "title"],
+            include: {
+                assignee: {
+                    select: ["name"],
+                    include: {
+                        department: {
+                            select: ["name"],
+                        },
+                    },
+                },
+            },
+        });
+        // The task.assignee relation is optional, so it should LEFT JOIN
+        expect(result.joins[0]?.type).toBe("LEFT");
+        // Because assignee is optional and has nested joins, it should
+        // use a subquery to preserve LEFT JOIN semantics
+        expect(result.joins[0]?.subquery).toBeDefined();
+        expect(result.joins[0]?.subquery?.alias).toBe("b_subq");
+        // The nested join (employee.department) should be inside the subquery
+        expect(result.joins[0]?.subquery?.joins).toHaveLength(1);
+        expect(result.joins[0]?.subquery?.joins[0]?.relation).toBe("department");
+        expect(result.joins[0]?.subquery?.joins[0]?.type).toBe("INNER");
+        // The columns should reference the subquery alias
+        const assigneeColumns = result.columns.filter((col) => col.path[0] === "assignee");
+        expect(assigneeColumns.every((col) => col.table === "b_subq")).toBe(true);
+    });
 });

package/build/builders/types.d.ts

@@ -67,6 +67,11 @@ export type Join = {
     where?: SQLStatement | null;
     orderBy?: OrderBy[];
     path: string[];
+    subquery?: {
+        alias: string;
+        joins: Join[];
+        columns: SelectedColumn[];
+    };
 };
 export type LateralJoin = {
     outerAlias: string;

package/build/connection.js

@@ -76,7 +76,7 @@ export class Connection {
             }
         }
         catch (e) {
-            this.config.logger.error("Error running query");
+            this.config.logger.error(`Error running query: ${sql.pretty}`);
             throw e;
         }
     }

package/build/sql/findToSql.test.js

@@ -406,4 +406,132 @@ describe("findToSql", () => {
                 ) "b" ON TRUE
         `);
     });
+    test("generates query with subquery join for optional relations with nested joins", () => {
+        const statement = findToSql({
+            table: {
+                schema: "public",
+                name: "tasks",
+                alias: "a",
+                model: "task",
+            },
+            columns: [
+                { table: "a", name: "id", alias: "a_0", path: ["id"] },
+                { table: "a", name: "title", alias: "a_1", path: ["title"] },
+                {
+                    table: "b_subq",
+                    name: "b_0",
+                    alias: "b_0",
+                    path: ["assignee", "name"],
+                },
+                {
+                    table: "b_subq",
+                    name: "b_1",
+                    alias: "b_1",
+                    path: ["assignee", "id"],
+                },
+                {
+                    table: "b_subq",
+                    name: "c_0",
+                    alias: "c_0",
+                    path: ["assignee", "department", "name"],
+                },
+                {
+                    table: "b_subq",
+                    name: "c_1",
+                    alias: "c_1",
+                    path: ["assignee", "department", "id"],
+                },
+            ],
+            joins: [
+                {
+                    type: "LEFT",
+                    relation: "assignee",
+                    path: ["assignee"],
+                    table: {
+                        schema: "public",
+                        name: "employees",
+                        alias: "b",
+                        model: "employee",
+                    },
+                    columns: [
+                        {
+                            from: { table: "a", name: "assignee_id" },
+                            to: { table: "b_subq", name: "b_1" },
+                        },
+                    ],
+                    subquery: {
+                        alias: "b_subq",
+                        columns: [
+                            {
+                                table: "b",
+                                name: "name",
+                                alias: "b_0",
+                                path: ["assignee", "name"],
+                            },
+                            {
+                                table: "b",
+                                name: "id",
+                                alias: "b_1",
+                                path: ["assignee", "id"],
+                            },
+                            {
+                                table: "c",
+                                name: "name",
+                                alias: "c_0",
+                                path: ["assignee", "department", "name"],
+                            },
+                            {
+                                table: "c",
+                                name: "id",
+                                alias: "c_1",
+                                path: ["assignee", "department", "id"],
+                            },
+                        ],
+                        joins: [
+                            {
+                                type: "INNER",
+                                relation: "department",
+                                path: ["assignee", "department"],
+                                table: {
+                                    schema: "public",
+                                    name: "departments",
+                                    alias: "c",
+                                    model: "department",
+                                },
+                                columns: [
+                                    {
+                                        from: { table: "b", name: "department_id" },
+                                        to: { table: "c", name: "id" },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                },
+            ],
+            orderBy: [],
+            tableIndex: 0,
+        });
+        expect(statement.pretty).toBe(unindent `
+            SELECT
+                "a"."id" AS "a_0",
+                "a"."title" AS "a_1",
+                "b_subq"."b_0" AS "b_0",
+                "b_subq"."b_1" AS "b_1",
+                "b_subq"."c_0" AS "c_0",
+                "b_subq"."c_1" AS "c_1"
+            FROM
+                "public"."tasks" AS "a"
+                LEFT JOIN (
+                    SELECT
+                        "b"."name" AS "b_0",
+                        "b"."id" AS "b_1",
+                        "c"."name" AS "c_0",
+                        "c"."id" AS "c_1"
+                    FROM
+                        "public"."employees" AS "b"
+                        JOIN "public"."departments" AS "c" ON "b"."department_id" = "c"."id"
+                ) AS "b_subq" ON "a"."assignee_id" = "b_subq"."b_1"
+        `);
+    });
 });

package/build/sql/util.d.ts

@@ -6,5 +6,5 @@ export declare const selectColumn: ({ table, name, alias }: SelectedColumn) => S
 export declare const returnedColumn: ({ name, alias }: ReturnedColumn) => 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 joinClause: (join: Join) => SQLStatement;
 export declare const orderByColumn: (orderByColumn: OrderBy) => SQLStatement<import("pg").QueryResultRow>;

package/build/sql/util.js

@@ -18,12 +18,29 @@ 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 ")}
-    `;
+    if (join.subquery) {
+        // Build subquery with nested joins
+        const subquerySql = sql `
+            SELECT ${sql.join(join.subquery.columns.map(selectColumn))}
+            FROM ${tableName(join.table)}
+            ${sql.join(join.subquery.joins.map(joinClause), "\n")}
+            ${join.where ? sql `WHERE ${join.where}` : sql ``}
+        `;
+        const pkClauses = join.columns.map(({ from, to }) => sql `${columnName(from)} = ${sql.ident(to.table)}.${sql.ident(to.name)}`);
+        return sql `
+            ${join.type === "LEFT" ? sql `LEFT JOIN` : sql `JOIN`}
+            (${subquerySql}) AS ${sql.ident(join.subquery.alias)}
+            ON ${sql.join(pkClauses, " AND ")}
+        `;
+    }
+    else {
+        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 `

package/build/tests/connection.test.js

@@ -203,7 +203,7 @@ describe("Transaction", () => {
         test("rolling back on error", async () => {
             await transaction.query(sql `INSERT INTO transaction_test_table VALUES (2)`);
             await expect(transaction.query(sql `SELECT * FROM non_existent_table`)).rejects.toThrowError('relation "non_existent_table" does not exist');
-            expect(logger.logs.error[0]?.message).toEqual("Error running query");
+            expect(logger.logs.error[0]?.message).toContain("Error running query");
             expect(logger.logs.error[1]?.message).toEqual("Rolling back transaction due to error");
             const result = await connection.query(sql `SELECT * FROM transaction_test_table`);
             expect(result.rows.length).toBe(0);
@@ -285,7 +285,7 @@ describe("Transaction", () => {
         test("rolling back on error", async () => {
             await transaction.query(sql `INSERT INTO transaction_test_table VALUES (2)`);
             await expect(transaction.query(sql `SELECT * FROM non_existent_table`)).rejects.toThrowError('relation "non_existent_table" does not exist');
-            expect(logger.logs.error[0]?.message).toEqual("Error running query");
+            expect(logger.logs.error[0]?.message).toContain("Error running query");
             const result = await connection.query(sql `SELECT * FROM transaction_test_table`);
             expect(result.rows.length).toBe(0);
         });
@@ -293,7 +293,7 @@ describe("Transaction", () => {
             const nestedTx = await transaction.startTransaction();
             await nestedTx.query(sql `INSERT INTO transaction_test_table VALUES (2)`);
             await expect(nestedTx.query(sql `SELECT * FROM non_existent_table`)).rejects.toThrowError('relation "non_existent_table" does not exist');
-            expect(logger.logs.error[0]?.message).toEqual("Error running query");
+            expect(logger.logs.error[0]?.message).toContain("Error running query");
             expect(logger.logs.error[1]?.message).toEqual("Rolling back transaction due to error");
             await transaction.query(sql `INSERT INTO transaction_test_table VALUES (7)`);
             const result = await transaction.query(sql `SELECT * FROM transaction_test_table`);

package/build/tests/orm.findOne.includeManyToOne.test.js

@@ -277,4 +277,241 @@ describe("findOne: N:1 relations", () => {
             });
         }, { rollback: true });
     });
+    test("handles optional N:1 relation with nested non-optional relation using subquery", async () => {
+        await db.transact(async (db) => {
+            // Create departments
+            await db.createOne("department", {
+                values: factory.department({
+                    id: 1,
+                    name: "Engineering",
+                }),
+            });
+            await db.createOne("department", {
+                values: factory.department({
+                    id: 2,
+                    name: "Sales",
+                }),
+            });
+            // Create employees
+            await db.createOne("employee", {
+                values: factory.employee({
+                    id: 1,
+                    name: "Alice",
+                    departmentId: 1,
+                }),
+            });
+            await db.createOne("employee", {
+                values: factory.employee({
+                    id: 2,
+                    name: "Bob",
+                    departmentId: 2,
+                }),
+            });
+            // Create tasks - some with assignees, some without
+            await db.createMany("task", {
+                values: [
+                    factory.task({
+                        id: 1,
+                        title: "Task with Alice",
+                        assigneeId: 1,
+                    }),
+                    factory.task({
+                        id: 2,
+                        title: "Unassigned task",
+                        assigneeId: null,
+                    }),
+                    factory.task({
+                        id: 3,
+                        title: "Task with Bob",
+                        assigneeId: 2,
+                    }),
+                ],
+            });
+            // Test 1: Task with assignee and department
+            const taskWithAssignee = await db.findOne("task", {
+                select: ["id", "title"],
+                where: { id: 1 },
+                include: {
+                    assignee: {
+                        select: ["name"],
+                        include: {
+                            department: {
+                                select: ["name"],
+                            },
+                        },
+                    },
+                },
+            });
+            expect(taskWithAssignee).toEqual({
+                id: 1,
+                title: "Task with Alice",
+                assignee: {
+                    name: "Alice",
+                    department: {
+                        name: "Engineering",
+                    },
+                },
+            });
+            // Test 2: Task without assignee should return with null assignee
+            // This is the critical test - the LEFT JOIN with nested INNER JOIN
+            // should be wrapped in a subquery to preserve the NULL behavior
+            const unassignedTask = await db.findOne("task", {
+                select: ["id", "title"],
+                where: { id: 2 },
+                include: {
+                    assignee: {
+                        select: ["name"],
+                        include: {
+                            department: {
+                                select: ["name"],
+                            },
+                        },
+                    },
+                },
+            });
+            expect(unassignedTask).toEqual({
+                id: 2,
+                title: "Unassigned task",
+                assignee: null,
+            });
+            // Test 3: Verify Bob's task also works correctly
+            const bobsTask = await db.findOne("task", {
+                select: ["id", "title"],
+                where: { id: 3 },
+                include: {
+                    assignee: {
+                        select: ["name"],
+                        include: {
+                            department: {
+                                select: ["name"],
+                            },
+                        },
+                    },
+                },
+            });
+            expect(bobsTask).toEqual({
+                id: 3,
+                title: "Task with Bob",
+                assignee: {
+                    name: "Bob",
+                    department: {
+                        name: "Sales",
+                    },
+                },
+            });
+        }, { rollback: true });
+    });
+    test("handles where clauses on nested relations of optional N:1 relations", async () => {
+        await db.transact(async (db) => {
+            // Create departments
+            const engineering = await db.createOne("department", {
+                values: factory.department({
+                    id: 1,
+                    name: "Engineering",
+                }),
+                returning: ["id", "name"],
+            });
+            const sales = await db.createOne("department", {
+                values: factory.department({
+                    id: 2,
+                    name: "Sales",
+                }),
+                returning: ["id", "name"],
+            });
+            // Create employees in different departments
+            const alice = await db.createOne("employee", {
+                values: factory.employee({
+                    id: 1,
+                    name: "Alice",
+                    departmentId: 1,
+                }),
+                returning: ["id", "name"],
+            });
+            const bob = await db.createOne("employee", {
+                values: factory.employee({
+                    id: 2,
+                    name: "Bob",
+                    departmentId: 2,
+                }),
+                returning: ["id", "name"],
+            });
+            // Create tasks
+            const [task1, task2, task3] = await db.createMany("task", {
+                values: [
+                    factory.task({
+                        id: 1,
+                        title: "Engineering task",
+                        assigneeId: alice.id,
+                    }),
+                    factory.task({
+                        id: 2,
+                        title: "Sales task",
+                        assigneeId: bob.id,
+                    }),
+                    factory.task({
+                        id: 3,
+                        title: "Unassigned task",
+                        assigneeId: null,
+                    }),
+                ],
+                returning: ["id", "title"],
+            });
+            // Test 1: optional N:1 relation (assignee) includes non-optional department
+            const engineeringTasks = await db.findMany("task", {
+                select: ["id", "title"],
+                include: {
+                    assignee: {
+                        select: ["id", "name"],
+                        include: {
+                            department: {
+                                select: ["id", "name"],
+                                where: { name: "Engineering" },
+                            },
+                        },
+                    },
+                },
+                orderBy: ["id"],
+            });
+            // All tasks are returned (because assignee is optional)
+            // Only assignees in Engineering dept are returned
+            // Task 3 is filtered out (no assignee)
+            expect(engineeringTasks).toEqual([
+                {
+                    ...task1,
+                    assignee: {
+                        ...alice,
+                        department: { ...engineering },
+                    },
+                },
+                { ...task2, assignee: null },
+                { ...task3, assignee: null },
+            ]);
+            // Test 2: Where clause on the assignee itself (not nested department)
+            const aliceTasks = await db.findMany("task", {
+                select: ["id", "title"],
+                include: {
+                    assignee: {
+                        select: ["id", "name"],
+                        where: { name: "Alice" },
+                        include: {
+                            department: {
+                                select: ["id", "name"],
+                            },
+                        },
+                    },
+                },
+                orderBy: ["id"],
+            });
+            // Only task 1 should be returned (assigned to Alice)
+            expect(aliceTasks).toEqual([
+                {
+                    ...task1,
+                    assignee: {
+                        ...alice,
+                        department: { ...engineering },
+                    },
+                },
+            ]);
+        }, { rollback: true });
+    });
 });

package/build/tests/util/db.d.ts

@@ -522,6 +522,86 @@ export declare const createTestDB: (overrides?: Partial<Omit<Config, "models">>)
                     };
                 };
             };
+            department: {
+                readonly fields: {
+                    readonly id: {
+                        readonly type: "serial";
+                        readonly primaryKey: true;
+                    };
+                    readonly name: {
+                        readonly type: "text";
+                    };
+                };
+                readonly relations: {
+                    readonly employees: {
+                        readonly type: "1:N";
+                        readonly model: "employee";
+                        readonly fromField: "id";
+                        readonly toField: "departmentId";
+                    };
+                };
+            };
+            employee: {
+                readonly fields: {
+                    readonly id: {
+                        readonly type: "serial";
+                        readonly primaryKey: true;
+                    };
+                    readonly name: {
+                        readonly type: "text";
+                    };
+                    readonly departmentId: {
+                        readonly type: "integer";
+                        readonly references: {
+                            readonly model: "department";
+                            readonly field: "id";
+                        };
+                    };
+                };
+                readonly relations: {
+                    readonly department: {
+                        readonly type: "N:1";
+                        readonly model: "department";
+                        readonly fromField: "departmentId";
+                        readonly toField: "id";
+                    };
+                    readonly tasks: {
+                        readonly type: "1:N";
+                        readonly model: "task";
+                        readonly fromField: "id";
+                        readonly toField: "assigneeId";
+                    };
+                };
+            };
+            task: {
+                readonly fields: {
+                    readonly id: {
+                        readonly type: "serial";
+                        readonly primaryKey: true;
+                    };
+                    readonly title: {
+                        readonly type: "text";
+                    };
+                    readonly assigneeId: {
+                        readonly type: "integer";
+                        readonly nullable: true;
+                        readonly references: {
+                            readonly model: "employee";
+                            readonly field: "id";
+                            readonly onDelete: "SET NULL";
+                        };
+                    };
+                };
+                readonly relations: {
+                    readonly assignee: {
+                        readonly type: "N:1";
+                        readonly model: "employee";
+                        readonly fromField: "assigneeId";
+                        readonly toField: "id";
+                        readonly optional: true;
+                    };
+                };
+            };
         };
     }, {
         audit: {
@@ -1034,6 +1114,86 @@ export declare const createTestDB: (overrides?: Partial<Omit<Config, "models">>)
                 };
             };
         };
+        department: {
+            readonly fields: {
+                readonly id: {
+                    readonly type: "serial";
+                    readonly primaryKey: true;
+                };
+                readonly name: {
+                    readonly type: "text";
+                };
+            };
+            readonly relations: {
+                readonly employees: {
+                    readonly type: "1:N";
+                    readonly model: "employee";
+                    readonly fromField: "id";
+                    readonly toField: "departmentId";
+                };
+            };
+        };
+        employee: {
+            readonly fields: {
+                readonly id: {
+                    readonly type: "serial";
+                    readonly primaryKey: true;
+                };
+                readonly name: {
+                    readonly type: "text";
+                };
+                readonly departmentId: {
+                    readonly type: "integer";
+                    readonly references: {
+                        readonly model: "department";
+                        readonly field: "id";
+                    };
+                };
+            };
+            readonly relations: {
+                readonly department: {
+                    readonly type: "N:1";
+                    readonly model: "department";
+                    readonly fromField: "departmentId";
+                    readonly toField: "id";
+                };
+                readonly tasks: {
+                    readonly type: "1:N";
+                    readonly model: "task";
+                    readonly fromField: "id";
+                    readonly toField: "assigneeId";
+                };
+            };
+        };
+        task: {
+            readonly fields: {
+                readonly id: {
+                    readonly type: "serial";
+                    readonly primaryKey: true;
+                };
+                readonly title: {
+                    readonly type: "text";
+                };
+                readonly assigneeId: {
+                    readonly type: "integer";
+                    readonly nullable: true;
+                    readonly references: {
+                        readonly model: "employee";
+                        readonly field: "id";
+                        readonly onDelete: "SET NULL";
+                    };
+                };
+            };
+            readonly relations: {
+                readonly assignee: {
+                    readonly type: "N:1";
+                    readonly model: "employee";
+                    readonly fromField: "assigneeId";
+                    readonly toField: "id";
+                    readonly optional: true;
+                };
+            };
+        };
     }, {
         where: never;
     }>;
@@ -1549,5 +1709,85 @@ export declare const createTestDB: (overrides?: Partial<Omit<Config, "models">>)
                 };
             };
         };
+        department: {
+            readonly fields: {
+                readonly id: {
+                    readonly type: "serial";
+                    readonly primaryKey: true;
+                };
+                readonly name: {
+                    readonly type: "text";
+                };
+            };
+            readonly relations: {
+                readonly employees: {
+                    readonly type: "1:N";
+                    readonly model: "employee";
+                    readonly fromField: "id";
+                    readonly toField: "departmentId";
+                };
+            };
+        };
+        employee: {
+            readonly fields: {
+                readonly id: {
+                    readonly type: "serial";
+                    readonly primaryKey: true;
+                };
+                readonly name: {
+                    readonly type: "text";
+                };
+                readonly departmentId: {
+                    readonly type: "integer";
+                    readonly references: {
+                        readonly model: "department";
+                        readonly field: "id";
+                    };
+                };
+            };
+            readonly relations: {
+                readonly department: {
+                    readonly type: "N:1";
+                    readonly model: "department";
+                    readonly fromField: "departmentId";
+                    readonly toField: "id";
+                };
+                readonly tasks: {
+                    readonly type: "1:N";
+                    readonly model: "task";
+                    readonly fromField: "id";
+                    readonly toField: "assigneeId";
+                };
+            };
+        };
+        task: {
+            readonly fields: {
+                readonly id: {
+                    readonly type: "serial";
+                    readonly primaryKey: true;
+                };
+                readonly title: {
+                    readonly type: "text";
+                };
+                readonly assigneeId: {
+                    readonly type: "integer";
+                    readonly nullable: true;
+                    readonly references: {
+                        readonly model: "employee";
+                        readonly field: "id";
+                        readonly onDelete: "SET NULL";
+                    };
+                };
+            };
+            readonly relations: {
+                readonly assignee: {
+                    readonly type: "N:1";
+                    readonly model: "employee";
+                    readonly fromField: "assigneeId";
+                    readonly toField: "id";
+                    readonly optional: true;
+                };
+            };
+        };
     }>;
 };

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@casekit/orm2",
   "description": "",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "author": "",
   "dependencies": {
     "es-toolkit": "^1.39.3",
     "object-hash": "^3.0.0",
     "pino": "^9.7.0",
     "uuid": "^11.1.0",
-    "@casekit/orm2-config": "1.0.1",
-    "@casekit/orm2-schema": "1.0.1",
-    "@casekit/sql": "1.0.1",
-    "@casekit/toolbox": "1.0.1"
+    "@casekit/orm2-config": "1.0.2",
+    "@casekit/orm2-schema": "1.0.2",
+    "@casekit/toolbox": "1.0.2",
+    "@casekit/sql": "1.0.2"
   },
   "devDependencies": {
     "@casekit/unindent": "^1.0.5",
@@ -31,10 +31,10 @@
     "typescript-eslint": "^8.34.1",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.4",
-    "@casekit/orm2-fixtures": "1.0.1",
-    "@casekit/orm2-testing": "1.0.1",
-    "@casekit/prettier-config": "1.0.1",
-    "@casekit/tsconfig": "1.0.1"
+    "@casekit/orm2-fixtures": "1.0.2",
+    "@casekit/orm2-testing": "1.0.2",
+    "@casekit/tsconfig": "1.0.2",
+    "@casekit/prettier-config": "1.0.2"
   },
   "exports": {
     ".": "./build/index.js"