@casekit/orm 0.0.1-alpha.6 → 0.0.1-alpha.8

package/src/orm.ts

@@ -330,7 +330,7 @@ export class Orm<
         ...variables: readonly unknown[]
     ): Promise<T[]> {
         const query = sql(fragments, ...variables);
-        if (!process.env.CI) {
+        if (process.env.ORM_VERBOSE_LOGGING) {
             console.log(query.text);
             console.log(query.values);
         }
@@ -343,7 +343,10 @@ export class Orm<
         ...variables: readonly unknown[]
     ): Promise<T> {
         const query = sql(fragments, ...variables);
-        if (!process.env.CI) console.log(query.text);
+        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/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/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,7 +20,10 @@ export const count = async (
         values: statement.values,
     });
 
-    if (!process.env.CI) console.log(statement.text);
+    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

@@ -6,7 +6,7 @@ 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 }[];
@@ -21,7 +21,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: [],

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) => {

package/src/queries/createMany.ts

@@ -26,7 +26,10 @@ export const createMany = async (
         values: statement.values,
     });
 
-    if (!process.env.CI) console.log(statement.text);
+    if (process.env.ORM_VERBOSE_LOGGING) {
+        console.log(statement.text);
+        console.log(statement.values);
+    }
 
     const result = await conn.query(statement);
     return params.returning

package/src/queries/createOne.ts

@@ -1,5 +1,6 @@
 import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
 
+import { OrmError } from "..";
 import { Connection } from "../Connection";
 import { BaseCreateOneParams } from "./create/types/BaseCreateOneParams";
 import { createMany } from "./createMany";
@@ -10,6 +11,14 @@ export const createOne = async (
     m: string,
     params: BaseCreateOneParams,
 ) => {
+    if (params.onConflict?.do === "nothing" && params.returning) {
+        throw new OrmError(
+            "Cannot use 'returning' with 'onConflict' in createOne",
+            {
+                data: { m, params },
+            },
+        );
+    }
     const result = await createMany(conn, config, m, {
         ...params,
         values: [params.values],

package/src/queries/delete/buildDelete.ts

@@ -9,7 +9,7 @@ import { BaseDeleteParams } from "./types/BaseDeleteParams";
 
 export type DeleteBuilder = {
     tableIndex: number;
-    table: { name: string; model: string; alias: string; schema: string };
+    table: { table: string; model: string; alias: string; schema: string };
     where: WhereClause<LooseModelDefinitions, ModelName<LooseModelDefinitions>>;
     returning: { name: string; path: string; alias: string }[];
 };
@@ -23,7 +23,7 @@ export const buildDelete = (
     const builder: DeleteBuilder = {
         tableIndex: _tableIndex,
         table: {
-            name: config.models[m].table,
+            table: config.models[m].table,
             schema: config.models[m].schema,
             model: m,
             alias: tableAlias(_tableIndex++),

package/src/queries/delete/deleteResultSchema.ts

@@ -14,7 +14,9 @@ export const deleteResultSchema = (
 
     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/delete/deleteToSql.ts

@@ -16,7 +16,7 @@ export const deleteToSql = (
 
     const frag = sql`DELETE FROM %I.%I AS %I`.withIdentifiers(
         table.schema,
-        table.name,
+        table.table,
         table.alias,
     );
 

package/src/queries/deleteMany.ts

@@ -21,7 +21,10 @@ export const deleteMany = async (
         values: statement.values,
     });
 
-    if (!process.env.CI) console.log(statement.text);
+    if (process.env.ORM_VERBOSE_LOGGING) {
+        console.log(statement.text);
+        console.log(statement.values);
+    }
 
     const result = await conn.query(statement);
     return params.returning

package/src/queries/find/buildFind.ts

@@ -14,27 +14,29 @@ export const buildFind = (
     _tableIndex = 0,
 ): FindBuilder => {
     const builder: FindBuilder = {
-        tableIndex: _tableIndex,
         columns: [],
-        tables: [],
+        table: {
+            table: config.models[m]["table"],
+            model: m,
+            schema: config.models[m]["schema"],
+            alias: tableAlias(_tableIndex++),
+            where: config.middleware.find?.where
+                ? config.middleware.find.where(query.where, {
+                      config,
+                      model: m,
+                  })
+                : query.where,
+            joins: [],
+        },
         orderBy: [],
+        tableIndex: _tableIndex,
     };
 
     const model = config.models[m];
 
-    const alias = tableAlias(builder.tableIndex++);
+    const alias = builder.table.alias;
     let colIndex = 0;
 
-    builder.tables.push({
-        name: config.models[m]["table"],
-        model: m,
-        schema: config.models[m]["schema"],
-        alias: alias,
-        where: config.middleware.find?.where
-            ? config.middleware.find.where(query.where, { config, model: m })
-            : query.where,
-    });
-
     // make sure we always select the model's primary key,
     // and if necessary the foreign key for a lateral join
     // - we'll strip them out later
@@ -64,34 +66,38 @@ export const buildFind = (
                 [...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,
+                        ),
+                    },
+                    type: relation.optional ? "left" : "inner",
+                    where: joinedTable.where,
+                },
+                ...joinedTable.joins,
+            );
             // this is admittedly a bit weird,
             // we wouldn't expect N:1 relations to specify
             // ordering, skipping, and limiting, and typescript
             // prevents users from doing this, but
             // we rely on them being present as part of the N:N
             // implementation
-            builder.tables.push(...otherTables);
             builder.columns.push(...joinBuilder.columns);
             builder.orderBy.push(...joinBuilder.orderBy);
             builder.limit = min([builder.limit, joinBuilder.limit]);

package/src/queries/find/findResultSchema.ts

@@ -12,13 +12,20 @@ export const findResultSchema = (
 
     query.select.forEach((field) => {
         const col = config.models[m].columns[field];
-        obj[field] = col.nullable ? col.zodSchema.nullable() : col.zodSchema;
+        obj[field] = col.nullable
+            ? col.zodSchema.nullish().transform((x) => x ?? null)
+            : col.zodSchema;
     });
 
     for (const [field, subquery] of Object.entries(query.include || {})) {
         const relation = config.relations[m][field];
         const schema = findResultSchema(config, relation.model, subquery!);
-        obj[field] = relation.type === "N:1" ? schema : z.array(schema);
+        obj[field] =
+            relation.type === "N:1"
+                ? relation.optional
+                    ? schema.nullish().transform((x) => x ?? null)
+                    : schema
+                : z.array(schema);
     }
 
     return z.object(obj);

package/src/queries/find/findToSql.ts

@@ -13,7 +13,7 @@ export const findToSql = (
     builder: FindBuilder,
 ): SQLStatement => {
     const frag = new SQLStatement();
-    const [table, ...joinedTables] = builder.tables;
+    const table = builder.table;
 
     if (builder.lateralBy) {
         const { columns, groupTable, itemTable } = builder.lateralBy;
@@ -43,46 +43,41 @@ export const findToSql = (
         ),
     );
 
-    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,
+                " %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)}`,
             );
         }
     }