@casekit/orm 0.0.1-alpha.0

package/src/queries/util/hasConditions.ts

@@ -0,0 +1,14 @@
+export const hasConditions = <T>(clause: T): clause is NonNullable<T> => {
+    if (clause === null || clause === undefined) return false;
+    switch (typeof clause) {
+        case "object": {
+            const keys = [
+                ...Object.keys(clause),
+                ...Object.getOwnPropertySymbols(clause),
+            ];
+            return keys.length > 0;
+        }
+        default:
+            return false;
+    }
+};

package/src/queries/util/rowToObject.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, test } from "vitest";
+
+import { FindBuilder } from "../find/types/FindBuilder";
+import { rowToObject } from "./rowToObject";
+
+const builder: Pick<FindBuilder, "columns"> = {
+    columns: [
+        {
+            alias: "a_0",
+            name: "id",
+            path: ["id"],
+            table: "a",
+        },
+        {
+            alias: "a_1",
+            name: "title",
+            path: ["title"],
+            table: "a",
+        },
+        {
+            alias: "a_2",
+            name: "content",
+            path: ["content"],
+            table: "a",
+        },
+        {
+            alias: "b_0",
+            name: "id",
+            path: ["author", "id"],
+            table: "b",
+        },
+        {
+            alias: "b_1",
+            name: "name",
+            path: ["author", "name"],
+            table: "b",
+        },
+        {
+            alias: "c_0",
+            name: "id",
+            path: ["author", "bio", "id"],
+            table: "c",
+        },
+        {
+            alias: "c_1",
+            name: "content",
+            path: ["author", "bio", "content"],
+            table: "c",
+        },
+    ],
+};
+
+describe("rowToObject", () => {
+    test("it converts a flat row with column aliases into a nested object with original field names", () => {
+        expect(
+            rowToObject(builder.columns)({
+                a_0: 3,
+                a_1: "hello it me",
+                a_2: "a very long blog post",
+                b_0: 2,
+                b_1: "russell",
+                c_0: 5,
+                c_1: "i'm russell",
+            }),
+        ).toEqual({
+            id: 3,
+            title: "hello it me",
+            content: "a very long blog post",
+            author: {
+                id: 2,
+                name: "russell",
+                bio: { id: 5, content: "i'm russell" },
+            },
+        });
+    });
+});

package/src/queries/util/rowToObject.ts

@@ -0,0 +1,9 @@
+import { set } from "lodash-es";
+
+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]), {});
+    };

package/src/queries/util/tableAlias.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, test } from "vitest";
+
+import { tableAlias } from "./tableAlias";
+
+describe("tableAlias", () => {
+    test.each([
+        [0, "a"],
+        [1, "b"],
+        [26, "aa"],
+        [27, "ab"],
+        [51, "az"],
+        [52, "ba"],
+        [104, "da"],
+        [105, "db"],
+        [42000, "bjck"],
+        [42001, "bjcl"],
+    ])("tableAlias(%s) => %s", (index, expected) => {
+        expect(tableAlias(index)).toEqual(expected);
+    });
+});

package/src/queries/util/tableAlias.ts

@@ -0,0 +1,10 @@
+export const tableAlias = (index: number): string => {
+    let result = "";
+    let curr = index;
+    do {
+        const remainder = curr % 26;
+        result = String.fromCharCode("a".charCodeAt(0) + remainder) + result;
+        curr = (curr - remainder) / 26 - 1;
+    } while (curr >= 0);
+    return result;
+};

package/src/schema/populate/composeMiddleware.ts

@@ -0,0 +1,51 @@
+import { last } from "lodash-es";
+
+import { Middleware } from "../../queries/middleware/Middleware";
+
+const compose = <V, Meta>(
+    ...middleware: (((v: V, meta: Meta) => V) | undefined)[]
+): ((v: V, meta: Meta) => V) => {
+    return middleware
+        .filter((fn): fn is NonNullable<typeof fn> => fn !== undefined)
+        .reduce(
+            (acc, fn) => (v, meta) => fn(acc(v, meta), meta),
+            (v, _meta) => v,
+        );
+};
+
+export const composeMiddleware = (middleware: Middleware[]): Middleware => {
+    const where = compose(...middleware.map((m) => m.where));
+    const values = compose(...middleware.map((m) => m.values));
+    return {
+        find: {
+            where: compose(...middleware.map((m) => m.find?.where), where),
+        },
+        count: {
+            where: compose(...middleware.map((m) => m.count?.where), where),
+        },
+        create: {
+            values: compose(...middleware.map((m) => m.create?.values), values),
+        },
+        update: {
+            values: compose(...middleware.map((m) => m.update?.values), values),
+            where: compose(...middleware.map((m) => m.update?.where), where),
+        },
+        delete: {
+            where: compose(...middleware.map((m) => m.delete?.where), where),
+            deleteOne: last(
+                middleware
+                    .map((m) => m.delete?.deleteOne)
+                    .filter(
+                        (fn): fn is NonNullable<typeof fn> => fn !== undefined,
+                    ),
+            ),
+            deleteMany: last(
+                middleware
+                    .map((m) => m.delete?.deleteMany)
+                    .filter(
+                        (fn): fn is NonNullable<typeof fn> => fn !== undefined,
+                    ),
+            ),
+        },
+    };
+};

package/src/schema/populate/populateConfiguration.ts

@@ -0,0 +1,48 @@
+import { identity, mapValues } from "lodash-es";
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+
+import { Connection } from "../../Connection";
+import { Configuration } from "../../types/Configuration";
+import { LooseModelDefinitions } from "../types/loose/LooseModelDefinitions";
+import { LooseRelationsDefinitions } from "../types/loose/LooseRelationsDefinitions";
+import { composeMiddleware } from "./composeMiddleware";
+import { populateModel } from "./populateModel";
+
+export const populateConfiguration = <
+    Models extends LooseModelDefinitions,
+    Relations extends LooseRelationsDefinitions<Models>,
+>(
+    config: Configuration<Models, Relations>,
+): BaseConfiguration => {
+    const schema = config.schema ?? "public";
+
+    const naming = {
+        ...config.naming,
+        table: config.naming?.table ?? identity,
+        column: config.naming?.column ?? identity,
+    };
+
+    const models = mapValues(config.models, (model, name) => {
+        return populateModel({ naming, schema }, name, model);
+    });
+
+    const relations = mapValues(models, (_, name) => {
+        return config.relations?.[name] ?? {};
+    });
+
+    const connection = new Connection(config.pool);
+
+    const extensions = config.extensions ?? [];
+
+    const middleware = composeMiddleware(config.middleware ?? []);
+
+    return {
+        naming,
+        schema,
+        models,
+        relations,
+        extensions,
+        connection,
+        middleware,
+    };
+};

package/src/schema/populate/populateModel.ts

@@ -0,0 +1,97 @@
+import { mapValues } from "lodash-es";
+import { BaseModel } from "src/schema/types/base/BaseModel";
+
+import { BaseConfiguration } from "../types/base/BaseConfiguration";
+import { ForeignKey } from "../types/constraints/ForeignKey";
+import { UniqueConstraint } from "../types/constraints/UniqueConstraint";
+import { LooseModelDefinition } from "../types/loose/LooseModelDefinition";
+import { suggestedColumnSchema } from "./suggestedColumnSchema";
+
+export const populateModel = (
+    config: Pick<BaseConfiguration, "naming" | "schema">,
+    name: string,
+    model: LooseModelDefinition,
+): BaseModel => {
+    const columns = mapValues(model.columns, (column, name) => ({
+        name: column.name ?? config.naming.column(name),
+        type: column.type,
+        zodSchema: column.zodSchema ?? suggestedColumnSchema(column.type),
+        nullable: column.nullable ?? false,
+        default: column.default ?? null,
+    }));
+
+    const primaryKey =
+        model.primaryKey ??
+        Object.entries(model.columns)
+            .filter(([, c]) => c.primaryKey)
+            .map(([name, c]) => c.name ?? config.naming.column(name));
+
+    const uniqueConstraints = [
+        ...(model.uniqueConstraints ?? []),
+        ...Object.entries(model.columns)
+            .filter(([, c]) => c.unique)
+            .map(([name, c]) => {
+                if (c.unique === true) {
+                    return { columns: [name] };
+                } else if (c.unique === false) {
+                    throw new Error(
+                        "can't happen but let's make typescript happy",
+                    );
+                } else {
+                    return {
+                        columns: [name ?? config.naming.column(name)],
+                        where: c.unique?.where,
+                        nullsNotDistinct: c.unique?.nullsNotDistinct,
+                    };
+                }
+            }),
+    ] as UniqueConstraint[];
+
+    const foreignKeys = [
+        ...(model.foreignKeys ?? []).map((fk) => ({
+            ...fk,
+            references: {
+                ...fk.references,
+                schema:
+                    fk.references.schema ??
+                    model.schema ??
+                    config.schema ??
+                    "public",
+            },
+        })),
+        ...Object.entries(model.columns)
+            .filter(([, c]) => c.references)
+            .map(([name, c]) => {
+                if (!c.references) {
+                    throw new Error(
+                        "can't happen but let's make typescript happy",
+                    );
+                } else {
+                    return {
+                        columns: [c.name ?? config.naming.column(name)],
+                        references: {
+                            schema:
+                                c.references.schema ??
+                                model.schema ??
+                                config.schema ??
+                                "public",
+                            table: c.references.table,
+                            columns: [c.references.column],
+                        },
+                        onUpdate: c.references.onUpdate,
+                        onDelete: c.references.onDelete,
+                    };
+                }
+            }),
+    ] as ForeignKey[];
+
+    return {
+        ...model,
+        table: model.table ?? config.naming.table(name),
+        schema: model.schema ?? config.schema ?? "public",
+        columns,
+        primaryKey,
+        uniqueConstraints,
+        foreignKeys,
+    };
+};

package/src/schema/populate/suggestedColumnSchema.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+
+/**
+ * This must be kept in sync with suggestedColumnSchema
+ * below, so when a zod schema is not provided we can
+ * still infer the expected type of a field.
+ */
+export type SuggestedColumnType<DataType> = DataType extends
+    | "bigint"
+    | "bigserial"
+    | "double precision"
+    | "integer"
+    | "real"
+    | "smallint"
+    | "smallserial"
+    | "serial"
+    ? number
+    : DataType extends "inet" | "json" | "jsonb" | "money" | "text" | "uuid"
+      ? string
+      : DataType extends "boolean"
+        ? boolean
+        : DataType extends `timestamp${string}`
+          ? Date
+          : unknown;
+
+/**
+ * TODO figure out if these are reasonable or if there are better
+ * alternatives - and what the values should be for the other datatypes
+ */
+export const suggestedColumnSchema = (type: string) => {
+    if (type.startsWith("character")) return z.string();
+    if (type.startsWith("numeric")) return z.number();
+    if (type.startsWith("timestamp")) return z.date();
+
+    switch (type) {
+        case "bigint":
+        case "bigserial":
+        case "double precision":
+        case "integer":
+        case "real":
+        case "smallint":
+        case "smallserial":
+        case "serial":
+            // sometimes (bigints) are returned as strings,
+            // so we coerce them here. if your application
+            // needs to deal with bigints larger than javascript's
+            // max int, you can specify your own schema instead
+            return z.coerce.number();
+        case "inet":
+        case "json":
+        case "jsonb":
+        case "money":
+        case "text":
+            return z.string();
+        case "uuid":
+            return z.string().uuid();
+        case "boolean":
+            return z.boolean();
+        default:
+            return z.unknown();
+    }
+};

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

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export type BaseColumn = {
+    name: string;
+    type: string;
+    zodSchema: z.ZodType<unknown>;
+    nullable: boolean;
+    default?: unknown;
+};

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

@@ -0,0 +1,14 @@
+import { Connection } from "../../../Connection";
+import { Middleware } from "../../../queries/middleware/Middleware";
+import { BaseModels } from "./BaseModels";
+import { BaseRelations } from "./BaseRelations";
+
+export type BaseConfiguration = {
+    models: BaseModels;
+    relations: BaseRelations;
+    extensions: string[];
+    naming: { column: (s: string) => string; table: (s: string) => string };
+    schema: string;
+    connection: Connection;
+    middleware: Middleware;
+};

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

@@ -0,0 +1,12 @@
+import { ForeignKey } from "../constraints/ForeignKey";
+import { UniqueConstraint } from "../constraints/UniqueConstraint";
+import { BaseColumn } from "./BaseColumn";
+
+export type BaseModel = {
+    table: string;
+    schema: string;
+    primaryKey: string[];
+    uniqueConstraints: UniqueConstraint[];
+    foreignKeys: ForeignKey[];
+    columns: Record<string, BaseColumn>;
+};

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

@@ -0,0 +1,3 @@
+import { BaseModel } from "./BaseModel";
+
+export type BaseModels = Record<string, BaseModel>;

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

@@ -0,0 +1,8 @@
+import { Orm } from "../../../orm";
+import { LooseModelDefinitions } from "../loose/LooseModelDefinitions";
+import { LooseRelationsDefinitions } from "../loose/LooseRelationsDefinitions";
+
+export type BaseOrm = Orm<
+    LooseModelDefinitions,
+    LooseRelationsDefinitions<LooseModelDefinitions>
+>;

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

@@ -0,0 +1,18 @@
+export type BaseRelation =
+    | {
+          model: string;
+          type: "N:N";
+          foreignKey: string | string[];
+          otherKey: string | string[];
+          through: string;
+      }
+    | {
+          model: string;
+          type: "N:1";
+          foreignKey: string | string[];
+      }
+    | {
+          model: string;
+          type: "1:N";
+          foreignKey: string | string[];
+      };

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

@@ -0,0 +1,3 @@
+import { BaseRelation } from "./BaseRelation";
+
+export type BaseRelations = Record<string, Record<string, BaseRelation>>;

package/src/schema/types/constraints/ForeignKey.ts

@@ -0,0 +1,13 @@
+import { SQLStatement } from "../../..";
+import { NonEmptyArray } from "../../../types/util/NonEmptyArray";
+
+export type ForeignKey = {
+    columns: NonEmptyArray<string>;
+    references: {
+        schema?: string;
+        table: string;
+        columns: NonEmptyArray<string>;
+    };
+    onUpdate?: SQLStatement;
+    onDelete?: SQLStatement;
+};

package/src/schema/types/constraints/UniqueConstraint.ts

@@ -0,0 +1,9 @@
+import { SQLStatement } from "../../..";
+import { NonEmptyArray } from "../../../types/util/NonEmptyArray";
+
+export type UniqueConstraint = {
+    name?: string;
+    columns: NonEmptyArray<string>;
+    where?: SQLStatement;
+    nullsNotDistinct?: boolean;
+};

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

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

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+
+import { SuggestedColumnType } from "../../populate/suggestedColumnSchema";
+import { LooseModelDefinitions } from "../loose/LooseModelDefinitions";
+import { ColumnName } from "./ColumnName";
+import { ModelName } from "./ModelName";
+
+type NonNullableColumnType<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+    C extends ColumnName<Models, M>,
+> =
+    Models[M]["columns"][C]["zodSchema"] extends z.ZodType<unknown>
+        ? z.infer<Models[M]["columns"][C]["zodSchema"]>
+        : SuggestedColumnType<Models[M]["columns"][C]["type"]>;
+
+export type ColumnType<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+    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

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

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

@@ -0,0 +1,13 @@
+import { LooseModelDefinitions } from "../loose/LooseModelDefinitions";
+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"]
+    ? false
+    : undefined extends Columns<Models, M>[C]["default"]
+      ? false
+      : true;

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

@@ -0,0 +1,9 @@
+import { LooseModelDefinitions } from "../loose/LooseModelDefinitions";
+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;

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

@@ -0,0 +1,12 @@
+import { LooseModelDefinitions } from "../loose/LooseModelDefinitions";
+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"
+    ? true
+    : false;

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

@@ -0,0 +1,6 @@
+import { LooseModelDefinitions } from "../loose/LooseModelDefinitions";
+
+export type ModelName<Models extends LooseModelDefinitions> = Extract<
+    keyof Models,
+    string
+>;

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

@@ -0,0 +1,74 @@
+import { z } from "zod";
+
+import { SQLStatement } from "../../../sql";
+
+export type LooseColumnDefinition<ColumnType = unknown> = {
+    /**
+     * The postgresql datatype of the column.
+     */
+    type: string;
+
+    /**
+     * The name of the column in the database. If not specified,
+     * it will be inferred based on the model's field name,
+     * with any column naming function (e.g. `snakeCase`) specified
+     * in the config applied.
+     */
+    name?: string;
+
+    /**
+     * A Zod schema used to infer the type of the column and to
+     * validate/transform data coming from the database.
+     * If not specified, a basic schema will be inferred based on the
+     * postgresql data type of the column. Specifying it
+     * allows to you configure more sophisticated parsing, validation,
+     * and transformations.
+     */
+    zodSchema?: z.ZodType<ColumnType>;
+
+    /**
+     * Are null values allowed in this column?
+     */
+    nullable?: boolean;
+
+    /**
+     * Does this column have a default value? This can be either a value such as a number or string,
+     * or if you want to specify a SQL function for the default, you can use the `sql` tagged
+     * template literal. So examples would include:
+     *
+     * default: 3,
+     *
+     * or
+     *
+     * default: "foo",
+     *
+     * or
+     *
+     * default: sql`uuid_generate_v4()`,
+     */
+    default?: ColumnType | SQLStatement | null;
+
+    /**
+     * Is this column unique? If so, you can specify a where clause to
+     * specify a partial unique index, and whether nulls should be considered
+     * distinct.
+     */
+    unique?: boolean | { where?: SQLStatement; nullsNotDistinct?: boolean };
+
+    /**
+     * Is this column a single-column primary key?
+     */
+    primaryKey?: boolean;
+
+    /**
+     * Is this column a foreign key? If so, you can specify the table and column it references,
+     * and what should happen on update or delete.
+     */
+    references?: {
+        schema?: string;
+        table: string;
+        column: string;
+        onUpdate?: SQLStatement;
+        onDelete?: SQLStatement;
+    };
+};