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

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;
 };

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

@@ -1,6 +1,6 @@
 export type LooseRelationDefinition =
     | { model: string; type: "1:N"; foreignKey: string }
-    | { model: string; type: "N:1"; foreignKey: string }
+    | { model: string; type: "N:1"; foreignKey: string; optional?: true }
     | {
           model: string;
           type: "N:N";

package/src/schema/types/relations/ManyToManyRelation.ts

@@ -8,8 +8,8 @@ export type ManyToManyRelation<Models extends LooseModelDefinitions> = {
             model: M2;
             through: J;
             type: "N:N";
-            foreignKey: ColumnName<Models, J> | ColumnName<Models, J>[];
-            otherKey: ColumnName<Models, J> | ColumnName<Models, J>[];
+            foreignKey: ColumnName<Models[J]> | ColumnName<Models[J]>[];
+            otherKey: ColumnName<Models[J]> | ColumnName<Models[J]>[];
         };
     };
 }[ModelName<Models>][ModelName<Models>];

package/src/schema/types/relations/ManyToOneRelation.ts

@@ -9,6 +9,6 @@ export type ManyToOneRelation<
     [M2 in ModelName<Models>]: {
         model: M2;
         type: "N:1";
-        foreignKey: ColumnName<Models, M> | ColumnName<Models, M>[];
+        foreignKey: ColumnName<Models[M]> | ColumnName<Models[M]>[];
     };
 }[ModelName<Models>];

package/src/schema/types/relations/OneToManyRelation.ts

@@ -6,6 +6,7 @@ export type OneToManyRelation<Models extends LooseModelDefinitions> = {
     [M2 in ModelName<Models>]: {
         model: M2;
         type: "1:N";
-        foreignKey: ColumnName<Models, M2> | ColumnName<Models, M2>[];
+        foreignKey: ColumnName<Models[M2]> | ColumnName<Models[M2]>[];
+        optional?: boolean;
     };
 }[ModelName<Models>];

package/src/schema/types/strict/ColumnDefinition.ts

@@ -72,4 +72,10 @@ export type ColumnDefinition<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;
 };

package/src/test/db/models/post.model.ts

@@ -15,6 +15,12 @@ export const post = {
             type: "uuid",
             references: { table: "user", column: "id" },
         },
+        reviewedById: {
+            name: "reviewed_by_id",
+            type: "uuid",
+            nullable: true,
+            references: { table: "user", column: "id" },
+        },
         publishedAt: { type: "timestamp", nullable: true },
         tags: { type: "text[][][][]", nullable: true },
         tenantId: {

package/src/test/db/models/post.relations.ts

@@ -7,6 +7,12 @@ export const post = {
         type: "N:1",
         foreignKey: "authorId",
     },
+    reviewedBy: {
+        model: "user",
+        type: "N:1",
+        foreignKey: "reviewedById",
+        optional: true,
+    },
     tenant: {
         model: "tenant",
         type: "N:1",

package/src/test/db/models/user.model.ts

@@ -7,6 +7,12 @@ export const user = {
     columns: {
         id: { type: "uuid", default: sql`uuid_generate_v4()` },
         username: { zodSchema: z.string(), type: "text" },
+        invitedById: {
+            name: "invited_by_id",
+            type: "uuid",
+            nullable: true,
+            references: { table: "user", column: "id" },
+        },
         joinedAt: {
             name: "created_at",
             zodSchema: z.date(),

package/src/test/db/models/user.relations.ts

@@ -7,6 +7,22 @@ export const user = {
         model: "post",
         foreignKey: "authorId",
     },
+    reviewedPosts: {
+        type: "1:N",
+        model: "post",
+        foreignKey: "reviewedById",
+    },
+    invitedBy: {
+        type: "N:1",
+        model: "user",
+        foreignKey: "invitedById",
+        optional: true,
+    },
+    invitedUsers: {
+        type: "1:N",
+        model: "user",
+        foreignKey: "invitedById",
+    },
     tenancies: {
         type: "1:N",
         model: "tenantUser",

package/src/types/ModelType.ts

@@ -1,7 +1,20 @@
+import { IsNullable } from "../schema/types/helpers/IsNullable";
 import { LooseModelDefinition } from "../schema/types/loose/LooseModelDefinition";
 import { ColumnName } from "./ColumnName";
 import { ColumnType } from "./ColumnType";
+import { Simplify } from "./util/Simplify";
 
-export type ModelType<Model extends LooseModelDefinition> = {
-    [C in ColumnName<Model>]: ColumnType<Model, C>;
-};
+export type NullableColumn<Model extends LooseModelDefinition> = {
+    [C in ColumnName<Model>]: IsNullable<Model, C> extends true ? C : never;
+}[ColumnName<Model>];
+
+export type ModelType<Model extends LooseModelDefinition> = Simplify<
+    {
+        [C in Exclude<ColumnName<Model>, NullableColumn<Model>>]: ColumnType<
+            Model,
+            C
+        >;
+    } & {
+        [C in NullableColumn<Model>]?: ColumnType<Model, C>;
+    }
+>;

package/.env

@@ -1,2 +0,0 @@
-PGDATABASE=orm
-PGPASSWORD=password

package/.eslintrc.cjs

@@ -1,69 +0,0 @@
-/** @type {import('eslint').Linter.Config} */
-module.exports = {
-    root: true,
-    parserOptions: {
-        ecmaVersion: "latest",
-        sourceType: "module",
-        ecmaFeatures: {
-            jsx: true,
-        },
-    },
-    env: {
-        browser: true,
-        commonjs: true,
-        es6: true,
-    },
-
-    // Base config
-    extends: ["eslint:recommended"],
-
-    ignorePatterns: ["vitest.config.ts"],
-
-    overrides: [
-        // Typescript
-        {
-            files: ["**/*.{ts,tsx}"],
-            plugins: ["@typescript-eslint", "import"],
-            parser: "@typescript-eslint/parser",
-            parserOptions: {
-                project: "./tsconfig.json",
-                tsconfigRootDir: "./",
-            },
-            settings: {
-                "import/internal-regex": "^~/",
-                "import/resolver": {
-                    node: {
-                        extensions: [".ts", ".tsx"],
-                    },
-                    typescript: {
-                        alwaysTryTypes: true,
-                    },
-                },
-            },
-            extends: [
-                "plugin:@typescript-eslint/recommended",
-                "plugin:import/recommended",
-                "plugin:import/typescript",
-            ],
-            rules: {
-                "@typescript-eslint/no-unused-vars": [
-                    "error",
-                    {
-                        argsIgnorePattern: "^_",
-                        varsIgnorePattern: "^_",
-                        caughtErrorsIgnorePattern: "^_",
-                    },
-                ],
-                "@typescript-eslint/no-floating-promises": "error",
-            },
-        },
-
-        // Node
-        {
-            files: [".eslintrc.cjs"],
-            env: {
-                node: true,
-            },
-        },
-    ],
-};

package/.github/actions/ci-setup/action.yml

@@ -1,19 +0,0 @@
-name: CI setup
-runs:
-    using: composite
-    steps:
-        - uses: pnpm/action-setup@v3
-          name: Install pnpm
-          with:
-              version: 8
-              run_install: false
-
-        - uses: actions/setup-node@v4
-          with:
-              node-version: 21
-              cache: pnpm
-              registry-url: "https://registry.npmjs.org"
-
-        - name: Install dependencies
-          run: pnpm install
-          shell: bash

package/.github/dependabot.yml

@@ -1,12 +0,0 @@
-version: 2
-updates:
-    - package-ecosystem: "npm"
-      directory: "/"
-      open-pull-requests-limit: 25
-      schedule:
-          interval: "daily"
-    - package-ecosystem: "github-actions"
-      directory: "/"
-      open-pull-requests-limit: 25
-      schedule:
-          interval: "daily"