@casekit/orm 0.0.1-alpha.2 → 0.0.1-alpha.21

package/src/orm.ts

@@ -328,8 +328,12 @@ export class Orm<
     public async query<T extends QueryResultRow>(
         fragments: TemplateStringsArray,
         ...variables: readonly unknown[]
-    ) {
+    ): Promise<T[]> {
         const query = sql(fragments, ...variables);
+        if (process.env.ORM_VERBOSE_LOGGING) {
+            console.log(query.text);
+            console.log(query.values);
+        }
         const result = await this.connection.query<T>(query);
         return result.rows;
     }
@@ -337,8 +341,12 @@ export class Orm<
     public async queryOne<T extends QueryResultRow>(
         fragments: TemplateStringsArray,
         ...variables: readonly unknown[]
-    ) {
+    ): Promise<T> {
         const query = sql(fragments, ...variables);
+        if (process.env.ORM_VERBOSE_LOGGING) {
+            console.log(query.text);
+            console.log(query.values);
+        }
         const result = await this.connection.query<T>(query);
         if (result.rowCount === 0 || result.rowCount === null)
             throw new OrmError("No rows returned from query");

package/src/queries/clauses/IncludeClause.ts

@@ -13,11 +13,27 @@ export type IncludeClause<
         model: ModelName<Models>;
     }
         ? Relations[M][R] extends { type: "N:1" }
-            ? FindOneParams<Models, Relations, Relations[M][R]["model"]>
+            ? Omit<
+                  FindOneParams<Models, Relations, Relations[M][R]["model"]>,
+                  // for can only be applied to the top level query
+                  "for"
+              >
             : Relations[M][R] extends { type: "1:N" }
-              ? FindManyParams<Models, Relations, Relations[M][R]["model"]>
+              ? Omit<
+                    FindManyParams<Models, Relations, Relations[M][R]["model"]>,
+                    // for can only be applied to the top level query
+                    "for"
+                >
               : Relations[M][R] extends { type: "N:N" }
-                ? FindManyParams<Models, Relations, Relations[M][R]["model"]>
+                ? Omit<
+                      FindManyParams<
+                          Models,
+                          Relations,
+                          Relations[M][R]["model"]
+                      >,
+                      // for can only be applied to the top level query
+                      "for"
+                  >
                 : never
         : never;
 };

package/src/queries/clauses/ReturningClause.ts

@@ -1,9 +1,7 @@
 import { ColumnName } from "../../schema/types/helpers/ColumnName";
-import { ModelName } from "../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../schema/types/loose/LooseModelDefinitions";
+import { LooseModelDefinition } from "../../schema/types/loose/LooseModelDefinition";
 import { NonEmptyArray } from "../../types/util/NonEmptyArray";
 
-export type ReturningClause<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-> = NonEmptyArray<ColumnName<Models, M>>;
+export type ReturningClause<Model extends LooseModelDefinition> = NonEmptyArray<
+    ColumnName<Model>
+>;

package/src/queries/clauses/SelectClause.ts

@@ -1,9 +1,7 @@
 import { ColumnName } from "../../schema/types/helpers/ColumnName";
-import { ModelName } from "../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../schema/types/loose/LooseModelDefinitions";
+import { LooseModelDefinition } from "../../schema/types/loose/LooseModelDefinition";
 import { NonEmptyArray } from "../../types/util/NonEmptyArray";
 
-export type SelectClause<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-> = NonEmptyArray<ColumnName<Models, M>>;
+export type SelectClause<Model extends LooseModelDefinition> = NonEmptyArray<
+    ColumnName<Model>
+>;

package/src/queries/clauses/WhereClause.ts

@@ -8,7 +8,7 @@ export type WhereClause<
     Models extends LooseModelDefinitions,
     M extends ModelName<Models>,
 > = {
-    [C in ColumnName<Models, M>]?: WhereClauseValue<Models, M, C>;
+    [C in ColumnName<Models[M]>]?: WhereClauseValue<Models, M, C>;
 } & {
     [$and]?: WhereClause<Models, M>[];
     [$or]?: WhereClause<Models, M>[];

package/src/queries/clauses/helpers/OptionalColumn.ts

@@ -1,19 +1,18 @@
 import { ColumnName } from "../../../schema/types/helpers/ColumnName";
 import { HasDefault } from "../../../schema/types/helpers/HasDefault";
 import { IsNullable } from "../../../schema/types/helpers/IsNullable";
+import { IsProvided } from "../../../schema/types/helpers/IsProvided";
 import { IsSerial } from "../../../schema/types/helpers/IsSerial";
-import { ModelName } from "../../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { LooseModelDefinition } from "../../../schema/types/loose/LooseModelDefinition";
 
-export type OptionalColumn<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-> = {
-    [C in ColumnName<Models, M>]: IsNullable<Models, M, C> extends true
+export type OptionalColumn<Model extends LooseModelDefinition> = {
+    [C in ColumnName<Model>]: IsNullable<Model, C> extends true
         ? C
-        : IsSerial<Models, M, C> extends true
+        : IsSerial<Model, C> extends true
           ? C
-          : HasDefault<Models, M, C> extends true
+          : HasDefault<Model, C> extends true
             ? C
-            : never;
-}[ColumnName<Models, M>];
+            : IsProvided<Model, C> extends true
+              ? C
+              : never;
+}[ColumnName<Model>];

package/src/queries/clauses/helpers/OptionalParams.ts

@@ -7,8 +7,8 @@ export type OptionalParams<
     Models extends LooseModelDefinitions,
     M extends ModelName<Models>,
 > =
-    OptionalColumn<Models, M> extends never
+    OptionalColumn<Models[M]> extends never
         ? unknown
         : {
-              [C in OptionalColumn<Models, M>]?: ColumnType<Models, M, C>;
+              [C in OptionalColumn<Models[M]>]?: ColumnType<Models, M, C>;
           };

package/src/queries/clauses/helpers/RequiredColumn.ts

@@ -1,9 +1,8 @@
 import { ColumnName } from "../../../schema/types/helpers/ColumnName";
-import { ModelName } from "../../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { LooseModelDefinition } from "../../../schema/types/loose/LooseModelDefinition";
 import { OptionalColumn } from "./OptionalColumn";
 
-export type RequiredColumn<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-> = Exclude<ColumnName<Models, M>, OptionalColumn<Models, M>>;
+export type RequiredColumn<Model extends LooseModelDefinition> = Exclude<
+    ColumnName<Model>,
+    OptionalColumn<Model>
+>;

package/src/queries/clauses/helpers/RequiredParams.ts

@@ -7,8 +7,8 @@ export type RequiredParams<
     Models extends LooseModelDefinitions,
     M extends ModelName<Models>,
 > =
-    RequiredColumn<Models, M> extends never
+    RequiredColumn<Models[M]> extends never
         ? unknown
         : {
-              [C in RequiredColumn<Models, M>]: ColumnType<Models, M, C>;
+              [C in RequiredColumn<Models[M]>]: ColumnType<Models, M, C>;
           };

package/src/queries/clauses/where/buildWhereClause.ts

@@ -19,7 +19,7 @@ export const buildWhereClause = (
     column: string,
     v: unknown,
 ): SQLStatement => {
-    if (v === null) {
+    if (v === null || v === undefined) {
         return sql`%I.%I IS NULL`.withIdentifiers(table, column);
     } else if (
         typeof v === "string" ||

package/src/queries/clauses/where/buildWhereClauses.test.ts

@@ -135,7 +135,7 @@ describe("buildWhereClauses", () => {
         ) => {
             const clause = buildWhereClauses(
                 db.config,
-                { name: "foo", schema: "casekit", model: "foo", alias: "a" },
+                { table: "foo", schema: "casekit", model: "foo", alias: "a" },
                 where,
             );
             expect(clause.text).toEqual(sql);

package/src/queries/clauses/where/buildWhereClauses.ts

@@ -8,7 +8,7 @@ import { $and, $not, $or } from "./operators";
 
 export const buildWhereClauses = (
     config: BaseConfiguration,
-    table: { name: string; schema: string; alias: string; model: string },
+    table: { table: string; schema: string; alias: string; model: string },
     where: WhereClause<LooseModelDefinitions, ModelName<LooseModelDefinitions>>,
 ): SQLStatement => {
     const clauses: SQLStatement[] = [];

package/src/queries/clauses/where/types/WhereClauseValue.ts

@@ -19,7 +19,7 @@ import {
 export type WhereClauseValue<
     Models extends LooseModelDefinitions,
     M extends ModelName<Models>,
-    C extends ColumnName<Models, M>,
+    C extends ColumnName<Models[M]>,
     T = ColumnType<Models, M, C>,
 > =
     | ColumnType<Models, M, C>

package/src/queries/count/buildCount.ts

@@ -13,23 +13,25 @@ export const buildCount = (
     _tableIndex = 0,
 ): CountBuilder => {
     const builder: CountBuilder = {
+        table: {
+            table: config.models[m]["table"],
+            model: m,
+            schema: config.models[m]["schema"],
+            alias: tableAlias(_tableIndex++),
+            joins: [],
+            where: config.middleware.count?.where
+                ? config.middleware.count.where(query.where, {
+                      config,
+                      model: m,
+                  })
+                : query.where,
+        },
         tableIndex: _tableIndex,
-        tables: [],
     };
 
     const model = config.models[m];
 
-    const alias = tableAlias(builder.tableIndex++);
-
-    builder.tables.push({
-        name: config.models[m]["table"],
-        model: m,
-        schema: config.models[m]["schema"],
-        alias: alias,
-        where: config.middleware.count?.where
-            ? config.middleware.count.where(query.where, { config, model: m })
-            : query.where,
-    });
+    const alias = builder.table.alias;
 
     for (const [r, subquery] of Object.entries(query.include ?? {})) {
         const relation = config.relations[m][r];
@@ -42,28 +44,32 @@ export const buildCount = (
                 [...path, r],
                 builder.tableIndex++,
             );
-            const [joinedTable, ...otherTables] = joinBuilder.tables;
-            builder.tables.push({
-                ...joinedTable,
-                joins: [
-                    ...(joinedTable.joins ?? []),
-                    {
-                        from: {
-                            table: alias,
-                            columns: ensureArray(relation.foreignKey).map(
-                                (c) => model.columns[c].name,
-                            ),
-                        },
-                        to: {
-                            table: joinedTable.alias,
-                            columns: joinedModel.primaryKey.map(
-                                (c) => joinedModel.columns[c].name,
-                            ),
-                        },
+            const joinedTable = joinBuilder.table;
+            builder.table.joins.push(
+                {
+                    from: {
+                        schema: config.models[m].schema,
+                        table: config.models[m].table,
+                        alias,
+                        model: m,
+                        columns: ensureArray(relation.foreignKey).map(
+                            (c) => model.columns[c].name,
+                        ),
+                    },
+                    to: {
+                        schema: joinedModel.schema,
+                        table: joinedTable.table,
+                        alias: joinedTable.alias,
+                        model: relation.model,
+                        columns: joinedModel.primaryKey.map(
+                            (c) => joinedModel.columns[c].name,
+                        ),
                     },
-                ],
-            });
-            builder.tables.push(...otherTables);
+                    where: joinedTable.where,
+                    type: relation.optional ? "left" : "inner",
+                },
+                ...joinedTable.joins,
+            );
         }
     }
 

package/src/queries/count/countToSql.ts

@@ -11,50 +11,45 @@ export const countToSql = (
     config: BaseConfiguration,
     builder: CountBuilder,
 ): SQLStatement => {
-    const [table, ...joinedTables] = builder.tables;
+    const table = builder.table;
 
     const frag = sql`SELECT count(1) as "count"`;
 
-    frag.push(pgfmt(`\nFROM %I.%I %I`, table.schema, table.name, table.alias));
+    frag.push(pgfmt(`\nFROM %I.%I %I`, table.schema, table.table, table.alias));
 
-    for (const joinedTable of joinedTables) {
-        if (!joinedTable.joins)
-            throw new OrmError("Joined table without join clauses", {
-                data: builder,
-            });
+    for (const join of table.joins ?? []) {
+        if (join.from.columns.length !== join.to.columns.length) {
+            throw new OrmError(
+                "Number of foreign keys doesn't match number of primary keys in join",
+                { data: builder },
+            );
+        }
+
+        frag.push(join.type === "left" ? "\nLEFT JOIN" : "\nJOIN");
         frag.push(
             pgfmt(
-                "\nJOIN %I.%I %I\n    ON ",
-                joinedTable.schema,
-                joinedTable.name,
-                joinedTable.alias,
+                "\n %I.%I %I\n    ON ",
+                join.to.schema,
+                join.to.table,
+                join.to.alias,
             ),
         );
         frag.push(
-            joinedTable.joins
-                .flatMap((join) => {
-                    if (join.from.columns.length !== join.to.columns.length) {
-                        throw new OrmError(
-                            "Number of foreign keys doesn't match number of primary keys in join",
-                            { data: builder },
-                        );
-                    }
-
-                    return join.from.columns.map((from, i) =>
-                        pgfmt(
-                            "%I.%I = %I.%I",
-                            table.alias,
-                            from,
-                            joinedTable.alias,
-                            join.to.columns[i],
-                        ),
-                    );
-                })
+            join.from.columns
+                .map((from, i) =>
+                    pgfmt(
+                        "%I.%I = %I.%I",
+                        join.from.alias,
+                        from,
+                        join.to.alias,
+                        join.to.columns[i],
+                    ),
+                )
                 .join(" AND "),
         );
-        if (hasConditions(joinedTable.where)) {
+        if (hasConditions(join.where)) {
             frag.push(
-                sql`\n    AND ${buildWhereClauses(config, joinedTable, joinedTable.where)}`,
+                sql`\n    AND ${buildWhereClauses(config, join.to, join.where)}`,
             );
         }
     }

package/src/queries/count/types/CountBuilder.ts

@@ -5,12 +5,12 @@ import { WhereClause } from "../../clauses/WhereClause";
 export type CountBuilder = {
     tableIndex: number;
 
-    tables: {
-        name: string;
+    table: {
+        table: string;
         model: string;
         schema: string;
         alias: string;
-        joins?: Join[];
+        joins: Join[];
         conditions?: WhereClause<
             LooseModelDefinitions,
             ModelName<LooseModelDefinitions>
@@ -19,10 +19,27 @@ export type CountBuilder = {
             LooseModelDefinitions,
             ModelName<LooseModelDefinitions>
         >;
-    }[];
+    };
 };
 
 export type Join = {
-    from: { table: string; columns: string[] };
-    to: { table: string; columns: string[] };
+    from: {
+        schema: string;
+        table: string;
+        alias: string;
+        model: string;
+        columns: string[];
+    };
+    to: {
+        schema: string;
+        table: string;
+        alias: string;
+        model: string;
+        columns: string[];
+    };
+    where?: WhereClause<
+        LooseModelDefinitions,
+        ModelName<LooseModelDefinitions>
+    >;
+    type?: "inner" | "left";
 };

package/src/queries/count.ts

@@ -20,8 +20,10 @@ export const count = async (
         values: statement.values,
     });
 
-    if (process.env.NODE_ENV === "test" && !process.env.CI)
+    if (process.env.ORM_VERBOSE_LOGGING) {
         console.log(statement.text);
+        console.log(statement.values);
+    }
 
     const result = await conn
         .query(statement)

package/src/queries/create/buildCreate.ts

@@ -1,3 +1,4 @@
+import { uniq } from "lodash-es";
 import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
 
 import { OrmError } from "../../errors";
@@ -6,8 +7,9 @@ import { BaseCreateManyParams } from "./types/BaseCreateManyParams";
 
 export type CreateBuilder = {
     tableIndex: number;
-    table: { name: string; schema: string };
+    table: { table: string; schema: string };
     params: { name: string; path: string; values: unknown[] }[];
+    onConflict?: { do: "nothing" };
     returning: { name: string; path: string; alias: string }[];
 };
 
@@ -20,7 +22,7 @@ export const buildCreate = (
     const builder: CreateBuilder = {
         tableIndex: _tableIndex,
         table: {
-            name: config.models[m].table,
+            table: config.models[m].table,
             schema: config.models[m].schema,
         },
         params: [],
@@ -42,7 +44,8 @@ export const buildCreate = (
             data: { m, params },
         });
 
-    for (const k of Object.keys(values[0])) {
+    const keys = uniq(values.flatMap((v) => Object.keys(v)));
+    for (const k of keys) {
         builder.params.push({
             name: model.columns[k]["name"],
             path: k,
@@ -58,5 +61,7 @@ export const buildCreate = (
         });
     }
 
+    builder.onConflict = params.onConflict;
+
     return builder;
 };

package/src/queries/create/createResultSchema.ts

@@ -15,7 +15,9 @@ export const createResultSchema = (
 
     params.returning?.forEach((s) => {
         const col = config.models[m].columns[s];
-        obj[s] = col.nullable ? col.zodSchema.nullable() : col.zodSchema;
+        obj[s] = col.nullable
+            ? col.zodSchema.nullish().transform((x) => x ?? null)
+            : col.zodSchema;
     });
 
     return z.object(obj);

package/src/queries/create/createToSql.ts

@@ -10,10 +10,14 @@ export const createToSql = (builder: CreateBuilder): SQLStatement => {
 
     if (params.length === 0) {
         frag.push(
-            pgfmt("INSERT INTO %I.%I DEFAULT VALUES", table.schema, table.name),
+            pgfmt(
+                "INSERT INTO %I.%I DEFAULT VALUES",
+                table.schema,
+                table.table,
+            ),
         );
     } else {
-        frag.push(pgfmt("INSERT INTO %I.%I (\n", table.schema, table.name));
+        frag.push(pgfmt("INSERT INTO %I.%I (\n", table.schema, table.table));
         frag.push(params.map((p) => pgfmt("    %I", p.name)).join(",\n"));
         frag.push(") VALUES ");
         const values = params[0].values.map((_, index) => {
@@ -22,6 +26,10 @@ export const createToSql = (builder: CreateBuilder): SQLStatement => {
         frag.push(sql.splat(values));
     }
 
+    if (builder.onConflict?.do === "nothing") {
+        frag.push("\nON CONFLICT DO NOTHING");
+    }
+
     if (returning.length > 0) {
         frag.push("\nRETURNING ");
         frag.push(

package/src/queries/create/tests/createMany.varied-keys.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "vitest";
+
+import { db } from "../../../test/db";
+
+describe("createMany", () => {
+    test("it can handle varied combinations of optional keys in its values", async () => {
+        await db.transact(
+            async (db) => {
+                const russell = await db.createOne("user", {
+                    values: { username: `Russell` },
+                    returning: ["id", "username"],
+                });
+                const others = await db.createMany("user", {
+                    values: [
+                        { username: "Fairooz" },
+                        { username: "Dan", invitedById: russell.id },
+                    ],
+                    returning: ["username", "invitedById"],
+                });
+                expect(others).toEqual([
+                    { username: "Fairooz", invitedById: null },
+                    { username: "Dan", invitedById: russell.id },
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+});

package/src/queries/create/tests/createOne.test.ts

@@ -124,4 +124,74 @@ describe("createOne", () => {
             { rollback: true },
         );
     });
+    test("columns that are provided by middleware do not need to be specified", async () => {
+        const baz = {
+            columns: {
+                id: {
+                    type: "uuid",
+                    zodSchema: z.string().uuid(),
+                    provided: true,
+                },
+                name: { type: "text", zodSchema: z.string() },
+            },
+        } as const satisfies ModelDefinition;
+
+        await orm({
+            schema: "casekit",
+            models: { baz },
+            relations: { baz: {} },
+            pool: new pg.Pool(),
+            middleware: [
+                {
+                    create: {
+                        values: (values) => ({ id: uuid.v4(), ...values }),
+                    },
+                },
+            ],
+        }).transact(
+            async (db) => {
+                await db.connection.query(createTableSql(db.models.baz));
+
+                await db.createOne("baz", {
+                    values: { name: "hello" },
+                });
+
+                const rows = await db.findMany("baz", {
+                    select: ["id", "name"],
+                });
+
+                expect(rows).toHaveLength(1);
+                expect(rows[0].id).toBeTypeOf("string");
+                expect(rows[0].name).toEqual("hello");
+            },
+            { rollback: true },
+        );
+    });
+
+    test("conflicts can be ignored", async () => {
+        await db.transact(
+            async (db) => {
+                await db.createOne("user", { values: { username: "russell" } });
+
+                // creating a duplicate user should throw an error
+                await expect(
+                    db.transact(async (db) => {
+                        return db.createOne("user", {
+                            values: { username: "russell" },
+                        });
+                    }),
+                ).rejects.toThrow(
+                    'duplicate key value violates unique constraint "user_username_idx"',
+                );
+
+                // but if we ignore the conflict, it should work
+                const result = await db.createOne("user", {
+                    values: { username: "russell" },
+                    onConflict: { do: "nothing" },
+                });
+                expect(result).toEqual(0);
+            },
+            { rollback: true },
+        );
+    });
 });

package/src/queries/create/types/BaseCreateManyParams.ts

@@ -2,5 +2,6 @@ import { NonEmptyArray } from "../../../types/util/NonEmptyArray";
 
 export type BaseCreateManyParams = {
     values: Record<string, unknown | null>[];
+    onConflict?: { do: "nothing" };
     returning?: NonEmptyArray<string>;
 };

package/src/queries/create/types/BaseCreateOneParams.ts

@@ -2,5 +2,6 @@ import { NonEmptyArray } from "../../../types/util/NonEmptyArray";
 
 export type BaseCreateOneParams = {
     values: Record<string, unknown | null>;
+    onConflict?: { do: "nothing" };
     returning?: NonEmptyArray<string>;
 };

package/src/queries/create/types/CreateManyParams.ts

@@ -8,5 +8,8 @@ export type CreateManyParams<
     M extends ModelName<Models>,
 > = {
     values: CreateValues<Models, M>[];
-    returning?: ReturningClause<Models, M>;
+    returning?: ReturningClause<Models[M]>;
+    onConflict?: {
+        do: "nothing";
+    };
 };