@casekit/orm 0.0.1-alpha.1 → 0.0.1-alpha.10

package/src/queries/find/types/BaseFindParams.ts

@@ -5,7 +5,7 @@ import { WhereClause } from "../../clauses/WhereClause";
 
 export type BaseFindParams = {
     select: string[];
-    include?: Partial<Record<string, BaseFindParams>>;
+    include?: Partial<Record<string, Omit<BaseFindParams, "for">>>;
     where?: WhereClause<
         LooseModelDefinitions,
         ModelName<LooseModelDefinitions>
@@ -13,5 +13,6 @@ export type BaseFindParams = {
     limit?: number;
     offset?: number;
     lateralBy?: LateralByClause;
+    for?: "update" | "no key update" | "share" | "key share";
     orderBy?: (string | [string, "asc" | "desc"])[];
 };

package/src/queries/find/types/FindBuilder.ts

@@ -12,12 +12,12 @@ export type FindBuilder = {
         path: string[];
     }[];
 
-    tables: {
-        name: string;
+    table: {
+        table: string;
         model: string;
         schema: string;
         alias: string;
-        joins?: Join[];
+        joins: Join[];
         conditions?: WhereClause<
             LooseModelDefinitions,
             ModelName<LooseModelDefinitions>
@@ -26,7 +26,7 @@ export type FindBuilder = {
             LooseModelDefinitions,
             ModelName<LooseModelDefinitions>
         >;
-    }[];
+    };
 
     lateralBy?: {
         groupTable: string;
@@ -38,6 +38,8 @@ export type FindBuilder = {
         }[];
     };
 
+    for?: "update" | "no key update" | "share" | "key share";
+
     orderBy: {
         table: string;
         column: string;
@@ -49,6 +51,23 @@ export type FindBuilder = {
     offset?: number;
 };
 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/find/types/FindManyParams.ts

@@ -12,12 +12,13 @@ export type FindManyParams<
     Relations extends LooseRelationsDefinitions<Models>,
     M extends ModelName<Models>,
 > = {
-    select: SelectClause<Models, M>;
+    select: SelectClause<Models[M]>;
     include?: IncludeClause<Models, Relations, M>;
     where?: WhereClause<Models, M>;
     limit?: number;
     offset?: number;
     orderBy?: NonEmptyArray<
-        ColumnName<Models, M> | [ColumnName<Models, M>, "asc" | "desc"]
+        ColumnName<Models[M]> | [ColumnName<Models[M]>, "asc" | "desc"]
     >;
+    for?: "update" | "no key update" | "share" | "key share";
 };

package/src/queries/find/types/FindOneParams.ts

@@ -10,7 +10,8 @@ export type FindOneParams<
     Relations extends LooseRelationsDefinitions<Models>,
     M extends ModelName<Models>,
 > = {
-    select: SelectClause<Models, M>;
+    select: SelectClause<Models[M]>;
     where?: WhereClause<Models, M>;
     include?: IncludeClause<Models, Relations, M>;
+    for?: "update" | "no key update" | "share" | "key share";
 };

package/src/queries/findMany.ts

@@ -1,4 +1,4 @@
-import { groupBy } from "lodash-es";
+import { dropRight, get, groupBy, set } from "lodash-es";
 import hash from "object-hash";
 import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
 
@@ -8,6 +8,8 @@ import { logger } from "../logger";
 import { ensureArray } from "../util/ensureArray";
 import { buildFind } from "./find/buildFind";
 import { findToSql } from "./find/findToSql";
+import { getIncludedManyToManyRelations } from "./find/getIncludedManyToManyRelations";
+import { getIncludedOneToManyRelations } from "./find/getIncludedOneToManyRelations";
 import { BaseFindParams } from "./find/types/BaseFindParams";
 import { rowToObject } from "./util/rowToObject";
 
@@ -25,89 +27,108 @@ export const findMany = 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 results = await conn
         .query(statement)
         .then((result) => result.rows.map(rowToObject(builder.columns)));
 
-    for (const [r, subquery] of Object.entries(query.include ?? {})) {
-        const relation = config.relations[m]![r];
-        if (relation.type === "1:N") {
-            const relation = config.relations[m][r];
-
-            const pk = config.models[m].primaryKey;
-            const fk = ensureArray(relation.foreignKey);
-
-            const lateralBy = fk.map((c, index) => ({
-                column: c,
-                values: results.map((result) => result[pk[index]]),
-            }));
-
-            const subqueryResults = await findMany(
-                conn,
-                config,
-                relation.model,
-                { ...subquery!, lateralBy },
-            );
-
+    const fetchIncludedOneToManyRelations = getIncludedOneToManyRelations(
+        config,
+        m,
+        query,
+    ).map(({ model, relation, query, path }) => {
+        const pk = config.models[model].primaryKey;
+        const fk = ensureArray(relation.foreignKey);
+        const lateralBy = fk.map((c, index) => ({
+            column: c,
+            values: results.map((result) =>
+                get(result, [...dropRight(path, 1), pk[index]]),
+            ),
+        }));
+        return findMany(conn, config, relation.model, {
+            ...query,
+            for: builder.for,
+            lateralBy,
+        }).then((subqueryResults) => {
             const lookup = groupBy(subqueryResults, (result) => {
                 return hash(fk.map((c) => result[c]));
             });
-
             for (const result of results) {
-                const key = hash(pk.map((c) => result[c]));
-                result[r] = lookup[key] ?? [];
-            }
-        } else if (relation.type === "N:N") {
-            const joinFrom = Object.entries(config.relations[m]).find(
-                ([, rel]) =>
-                    rel.type === "1:N" && rel.model === relation.through,
-            )?.[0];
-
-            const joinTo = Object.entries(
-                config.relations[relation.through],
-            ).find(
-                ([, rel]) => rel.type === "N:1" && rel.model === relation.model,
-            )?.[0];
-
-            if (joinFrom === undefined || joinTo === undefined) {
-                throw new OrmError(
-                    "Both sides of a N:N relation must be defined",
-                    { data: { joinFrom, joinTo, query } },
-                );
+                const parent =
+                    path.length === 1
+                        ? result
+                        : get(result, dropRight(path, 1));
+                if (parent !== undefined) {
+                    const key = hash(pk.map((c) => get(parent, c)));
+                    set(result, path, lookup[key] ?? []);
+                }
             }
+        });
+    });
 
-            const pk = config.models[m].primaryKey;
-            const fk = ensureArray(relation.foreignKey);
-            const lateralBy = fk.map((c, index) => ({
-                column: c,
-                values: results.map((result) => result[pk[index]]),
-            }));
+    const fetchIncludedManyToManyRelations = getIncludedManyToManyRelations(
+        config,
+        m,
+        query,
+    ).map(({ model, relation, query, path }) => {
+        const joinFrom = Object.entries(config.relations[model]).find(
+            ([, rel]) => rel.type === "1:N" && rel.model === relation.through,
+        )?.[0];
+
+        const joinTo = Object.entries(config.relations[relation.through]).find(
+            ([, rel]) => rel.type === "N:1" && rel.model === relation.model,
+        )?.[0];
+
+        if (joinFrom === undefined || joinTo === undefined) {
+            throw new OrmError("Both sides of a N:N relation must be defined", {
+                data: { joinFrom, joinTo, query },
+            });
+        }
 
-            const subqueryResults = await findMany(
-                conn,
-                config,
-                relation.through,
-                {
-                    select: ensureArray(relation.foreignKey),
-                    include: { [joinTo]: subquery! },
-                    lateralBy,
-                },
-            );
+        const pk = config.models[model].primaryKey;
+        const fk = ensureArray(relation.foreignKey);
+        const lateralBy = fk.map((c, index) => ({
+            column: c,
+            values: results.map((result) =>
+                get(result, [...dropRight(path, 1), pk[index]]),
+            ),
+        }));
+
+        return findMany(conn, config, relation.through, {
+            select: ensureArray(relation.foreignKey),
+            include: { [joinTo]: query },
+            for: builder.for,
+            lateralBy,
+        }).then((subqueryResults) => {
             const lookup = groupBy(subqueryResults, (result) => {
                 return hash(fk.map((c) => result[c]));
             });
-
             for (const result of results) {
-                const key = hash(pk.map((c) => result[c]));
-                result[r] = (lookup[key] ?? []).map(
-                    (relation) => relation[joinTo] ?? [],
-                );
+                const parent =
+                    path.length === 1
+                        ? result
+                        : get(result, dropRight(path, 1));
+
+                if (parent !== undefined) {
+                    const key = hash(pk.map((c) => get(parent, c)));
+                    set(
+                        result,
+                        path,
+                        (lookup[key] ?? []).map((r) => r[joinTo] ?? []),
+                    );
+                }
             }
-        }
-    }
+        });
+    });
+
+    await Promise.all([
+        ...fetchIncludedOneToManyRelations,
+        ...fetchIncludedManyToManyRelations,
+    ]);
 
     return results;
 };

package/src/queries/middleware/Middleware.ts

@@ -15,7 +15,7 @@ export type Middleware = {
         values?: ValuesMiddleware;
     };
     update?: {
-        values?: ValuesMiddleware;
+        set?: ValuesMiddleware;
         where?: WhereMiddleware;
     };
     count?: {

package/src/queries/update/buildUpdate.ts

@@ -9,9 +9,9 @@ import { BaseUpdateParams } from "./types/BaseUpdateParams";
 
 export type UpdateBuilder = {
     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>>;
-    values: { name: string; value: unknown }[];
+    set: { name: string; value: unknown }[];
     returning: { name: string; path: string; alias: string }[];
 };
 
@@ -24,7 +24,7 @@ export const buildUpdate = (
     const builder: UpdateBuilder = {
         tableIndex: _tableIndex,
         table: {
-            name: config.models[m].table,
+            table: config.models[m].table,
             schema: config.models[m].schema,
             model: m,
             alias: tableAlias(_tableIndex++),
@@ -35,19 +35,19 @@ export const buildUpdate = (
                   model: m,
               })!
             : params.where!,
-        values: [],
+        set: [],
         returning: [],
     };
     let colIndex = 0;
     const model = config.models[m];
-    const values = config.middleware.update?.values
-        ? config.middleware.update.values(params.values, {
+    const set = config.middleware.update?.set
+        ? config.middleware.update.set(params.set, {
               config,
               model: m,
           })
-        : params.values;
+        : params.set;
 
-    if (values.length === 0) {
+    if (set.length === 0) {
         throw new OrmError("No updates provided for update operation", {
             data: { m, model, params },
         });
@@ -59,8 +59,8 @@ export const buildUpdate = (
         });
     }
 
-    for (const [k, v] of Object.entries(values)) {
-        builder.values.push({
+    for (const [k, v] of Object.entries(set)) {
+        builder.set.push({
             name: model.columns[k]["name"],
             value: v,
         });

package/src/queries/update/tests/updateOne.test.ts

@@ -21,7 +21,7 @@ describe("updateOne", () => {
                 const user = users["Stewart House"];
 
                 const updated = await db.updateOne("user", {
-                    values: { username: "Stewart Home" },
+                    set: { username: "Stewart Home" },
                     where: { username: "Stewart House" },
                     returning: ["id", "username"],
                 });
@@ -56,7 +56,7 @@ describe("updateOne", () => {
 
                 await expect(
                     db.updateOne("user", {
-                        values: { username: "Stewart Home" },
+                        set: { username: "Stewart Home" },
                         where: { username: "Stewart Wrong" },
                         returning: ["id", "username"],
                     }),
@@ -91,7 +91,7 @@ describe("updateOne", () => {
 
                 await expect(
                     db.updateOne("user", {
-                        values: { joinedAt: new Date("2021-01-04") },
+                        set: { joinedAt: new Date("2021-01-04") },
                         where: { username: { [$like]: "Stewart %" } },
                         returning: ["id", "username"],
                     }),

package/src/queries/update/types/BaseUpdateParams.ts

@@ -4,7 +4,7 @@ import { NonEmptyArray } from "../../../types/util/NonEmptyArray";
 import { WhereClause } from "../../clauses/WhereClause";
 
 export type BaseUpdateParams = {
-    values: Record<string, unknown | null>;
+    set: Record<string, unknown | null>;
     where: WhereClause<LooseModelDefinitions, ModelName<LooseModelDefinitions>>;
     returning?: NonEmptyArray<string>;
 };

package/src/queries/update/types/UpdateManyResult.ts

@@ -9,7 +9,7 @@ export type UpdateManyResult<
     M extends ModelName<Models>,
     P extends UpdateParams<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/update/types/UpdateOneResult.ts

@@ -9,7 +9,7 @@ export type UpdateOneResult<
     M extends ModelName<Models>,
     P extends UpdateParams<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/update/types/UpdateParams.ts

@@ -8,7 +8,7 @@ export type UpdateParams<
     Models extends LooseModelDefinitions,
     M extends ModelName<Models>,
 > = {
-    values: UpdateValues<Models, M>;
+    set: UpdateValues<Models, M>;
     where: WhereClause<Models, M>;
-    returning?: ReturningClause<Models, M>;
+    returning?: ReturningClause<Models[M]>;
 };

package/src/queries/update/types/UpdateValues.ts

@@ -8,5 +8,5 @@ export type UpdateValues<
     Models extends LooseModelDefinitions,
     M extends ModelName<Models>,
 > = Simplify<{
-    [C in ColumnName<Models, M>]?: ColumnType<Models, M, C>;
+    [C in ColumnName<Models[M]>]?: ColumnType<Models, M, C>;
 }>;

package/src/queries/update/updateResultSchema.ts

@@ -14,7 +14,9 @@ export const updateResultSchema = (
 
     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/update/updateToSql.ts

@@ -10,15 +10,15 @@ export const updateToSql = (
     m: string,
     builder: UpdateBuilder,
 ): SQLStatement => {
-    const { table, where, values: update, returning } = builder;
+    const { table, where, set, returning } = builder;
 
     const frag = sql`UPDATE %I.%I AS %I\nSET`.withIdentifiers(
         table.schema,
-        table.name,
+        table.table,
         table.alias,
     );
 
-    const fields = update.map((field) => {
+    const fields = set.map((field) => {
         return sql`\n    %I = ${field.value}`.withIdentifiers(field.name);
     });
 

package/src/queries/updateMany.ts

@@ -21,8 +21,10 @@ export const updateMany = 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);
     return params.returning

package/src/queries/util/rowToObject.ts

@@ -5,5 +5,9 @@ export type ColumnMapping = { path: string | string[]; alias: string };
 export const rowToObject =
     (columns: ColumnMapping[]) =>
     (row: Record<string, unknown>): Record<string, unknown> => {
-        return columns.reduce((acc, c) => set(acc, c.path, row[c.alias]), {});
+        return columns.reduce(
+            (acc, c) =>
+                row[c.alias] !== null ? set(acc, c.path, row[c.alias]) : acc,
+            {},
+        );
     };

package/src/schema/populate/composeMiddleware.ts

@@ -27,7 +27,7 @@ export const composeMiddleware = (middleware: Middleware[]): Middleware => {
             values: compose(...middleware.map((m) => m.create?.values), values),
         },
         update: {
-            values: compose(...middleware.map((m) => m.update?.values), values),
+            set: compose(...middleware.map((m) => m.update?.set), values),
             where: compose(...middleware.map((m) => m.update?.where), where),
         },
         delete: {

package/src/schema/populate/populateModel.ts

@@ -18,6 +18,7 @@ export const populateModel = (
         zodSchema: column.zodSchema ?? suggestedColumnSchema(column.type),
         nullable: column.nullable ?? false,
         default: column.default ?? null,
+        provided: column.provided ?? false,
     }));
 
     const primaryKey =

package/src/schema/types/base/BaseColumn.ts

@@ -6,4 +6,5 @@ export type BaseColumn = {
     zodSchema: z.ZodType<unknown>;
     nullable: boolean;
     default?: unknown;
+    provided: boolean;
 };

package/src/schema/types/base/BaseRelation.ts

@@ -10,6 +10,7 @@ export type BaseRelation =
           model: string;
           type: "N:1";
           foreignKey: string | string[];
+          optional?: boolean;
       }
     | {
           model: string;

package/src/schema/types/helpers/ColumnName.ts

@@ -1,7 +1,6 @@
-import { LooseModelDefinitions } from "../loose/LooseModelDefinitions";
-import { ModelName } from "./ModelName";
+import { LooseModelDefinition } from "../loose/LooseModelDefinition";
 
-export type ColumnName<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-> = Extract<keyof Models[M]["columns"], string>;
+export type ColumnName<Model extends LooseModelDefinition> = Extract<
+    keyof Model["columns"],
+    string
+>;

package/src/schema/types/helpers/ColumnType.ts

@@ -8,7 +8,7 @@ import { ModelName } from "./ModelName";
 type NonNullableColumnType<
     Models extends LooseModelDefinitions,
     M extends ModelName<Models>,
-    C extends ColumnName<Models, M>,
+    C extends ColumnName<Models[M]>,
 > =
     Models[M]["columns"][C]["zodSchema"] extends z.ZodType<unknown>
         ? z.infer<Models[M]["columns"][C]["zodSchema"]>
@@ -17,7 +17,7 @@ type NonNullableColumnType<
 export type ColumnType<
     Models extends LooseModelDefinitions,
     M extends ModelName<Models>,
-    C extends ColumnName<Models, M>,
+    C extends ColumnName<Models[M]>,
 > = Models[M]["columns"][C]["nullable"] extends true
     ? NonNullableColumnType<Models, M, C> | null
     : NonNullableColumnType<Models, M, C>;

package/src/schema/types/helpers/Columns.ts

@@ -1,7 +1,3 @@
-import { LooseModelDefinitions } from "../loose/LooseModelDefinitions";
-import { ModelName } from "./ModelName";
+import { LooseModelDefinition } from "../loose/LooseModelDefinition";
 
-export type Columns<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-> = Models[M]["columns"];
+export type Columns<Model extends LooseModelDefinition> = Model["columns"];

package/src/schema/types/helpers/HasDefault.ts

@@ -1,13 +1,11 @@
-import { LooseModelDefinitions } from "../loose/LooseModelDefinitions";
+import { LooseModelDefinition } from "../loose/LooseModelDefinition";
 import { Columns } from "./Columns";
-import { ModelName } from "./ModelName";
 
 export type HasDefault<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-    C extends keyof Columns<Models, M>,
-> = null extends Columns<Models, M>[C]["default"]
+    Model extends LooseModelDefinition,
+    C extends keyof Columns<Model>,
+> = null extends Columns<Model>[C]["default"]
     ? false
-    : undefined extends Columns<Models, M>[C]["default"]
+    : undefined extends Columns<Model>[C]["default"]
       ? false
       : true;

package/src/schema/types/helpers/IsNullable.ts

@@ -1,9 +1,7 @@
-import { LooseModelDefinitions } from "../loose/LooseModelDefinitions";
+import { LooseModelDefinition } from "../loose/LooseModelDefinition";
 import { Columns } from "./Columns";
-import { ModelName } from "./ModelName";
 
 export type IsNullable<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-    C extends keyof Columns<Models, M>,
-> = Columns<Models, M>[C]["nullable"] extends true ? true : false;
+    Model extends LooseModelDefinition,
+    C extends keyof Columns<Model>,
+> = Columns<Model>[C]["nullable"] extends true ? true : false;

package/src/schema/types/helpers/IsProvided.ts

@@ -0,0 +1,8 @@
+import { LooseModelDefinition } from "../loose/LooseModelDefinition";
+import { ColumnName } from "./ColumnName";
+import { Columns } from "./Columns";
+
+export type IsProvided<
+    Model extends LooseModelDefinition,
+    C extends ColumnName<Model>,
+> = Columns<Model>[C]["provided"];

package/src/schema/types/helpers/IsSerial.ts

@@ -1,12 +1,10 @@
-import { LooseModelDefinitions } from "../loose/LooseModelDefinitions";
+import { LooseModelDefinition } from "../loose/LooseModelDefinition";
 import { ColumnName } from "./ColumnName";
 import { Columns } from "./Columns";
-import { ModelName } from "./ModelName";
 
 export type IsSerial<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-    C extends ColumnName<Models, M>,
-> = Columns<Models, M>[C]["type"] extends "serial" | "bigserial" | "smallserial"
+    Model extends LooseModelDefinition,
+    C extends ColumnName<Model>,
+> = Columns<Model>[C]["type"] extends "serial" | "bigserial" | "smallserial"
     ? true
     : false;

package/src/schema/types/loose/LooseColumnDefinition.ts

@@ -71,4 +71,10 @@ export type LooseColumnDefinition<ColumnType = unknown> = {
         onUpdate?: SQLStatement;
         onDelete?: SQLStatement;
     };
+
+    /**
+     * Is this column provided by middleware? If so, it will not be included in
+     * the set of required columns for inserts and updates.
+     */
+    provided?: boolean;
 };