@casekit/orm 0.0.1-alpha.7 → 0.0.1-alpha.9

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

@@ -3,20 +3,16 @@ 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
-            : IsProvided<Models, M, C> extends true
+            : IsProvided<Model, C> extends true
               ? C
               : never;
-}[ColumnName<Models, M>];
+}[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/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,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/create/types/CreateManyParams.ts

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

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

@@ -10,7 +10,7 @@ export type CreateManyResult<
     M extends ModelName<Models>,
     P extends CreateOneParams<Models, M> | CreateManyParams<Models, M>,
 > =
-    P["returning"] extends ReturningClause<Models, M>
+    P["returning"] extends ReturningClause<Models[M]>
         ? Readonly<{
               [C in P["returning"][number]]: ColumnType<Models, M, C>;
           }>[]

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

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

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

@@ -10,7 +10,7 @@ export type CreateOneResult<
     M extends ModelName<Models>,
     P extends CreateOneParams<Models, M> | CreateManyParams<Models, M>,
 > =
-    P["returning"] extends SelectClause<Models, M>
+    P["returning"] extends SelectClause<Models[M]>
         ? Readonly<{
               [C in P["returning"][number]]: ColumnType<Models, M, C>;
           }>

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/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/delete/types/DeleteManyResult.ts

@@ -9,7 +9,7 @@ export type DeleteManyResult<
     M extends ModelName<Models>,
     P extends DeleteParams<Models, M>,
 > =
-    P["returning"] extends ReturningClause<Models, M>
+    P["returning"] extends ReturningClause<Models[M]>
         ? Readonly<{
               [C in P["returning"][number]]: ColumnType<Models, M, C>;
           }>[]

package/src/queries/delete/types/DeleteOneResult.ts

@@ -9,7 +9,7 @@ export type DeleteOneResult<
     M extends ModelName<Models>,
     P extends DeleteParams<Models, M>,
 > =
-    P["returning"] extends ReturningClause<Models, M>
+    P["returning"] extends ReturningClause<Models[M]>
         ? Readonly<{
               [C in P["returning"][number]]: ColumnType<Models, M, C>;
           }>

package/src/queries/delete/types/DeleteParams.ts

@@ -8,5 +8,5 @@ export type DeleteParams<
     M extends ModelName<Models>,
 > = {
     where: WhereClause<Models, M>;
-    returning?: ReturningClause<Models, M>;
+    returning?: ReturningClause<Models[M]>;
 };

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