@casekit/orm 0.0.1-alpha.12 → 0.0.1-alpha.13

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

@@ -1,36 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import { hasConditions } from "./hasConditions";
-
-describe("hasConditions", () => {
-    test("should return true for non-empty clause", () => {
-        const clause = { field: "name", operator: "equals", value: "John" };
-        expect(hasConditions(clause)).toBe(true);
-    });
-
-    test("should return false for null clause", () => {
-        const clause = null;
-        expect(hasConditions(clause)).toBe(false);
-    });
-
-    test("should return false for undefined clause", () => {
-        const clause = undefined;
-        expect(hasConditions(clause)).toBe(false);
-    });
-
-    test("should return false for empty object clause", () => {
-        const clause = {};
-        expect(hasConditions(clause)).toBe(false);
-    });
-
-    test("should return true for an object clause that contains only symbol keys", () => {
-        const sym = Symbol("test");
-        const clause = { [sym]: 2 };
-        expect(hasConditions(clause)).toBe(true);
-    });
-
-    test("should return false for empty array clause", () => {
-        const clause: string[] = [];
-        expect(hasConditions(clause)).toBe(false);
-    });
-});

package/src/queries/util/hasConditions.ts

@@ -1,14 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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) =>
-                row[c.alias] !== null ? set(acc, c.path, row[c.alias]) : acc,
-            {},
-        );
-    };

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

@@ -1,20 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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: {
-            set: compose(...middleware.map((m) => m.update?.set), 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

@@ -1,48 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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,
-        provided: column.provided ?? false,
-    }));
-
-    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

@@ -1,62 +0,0 @@
-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

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

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

@@ -1,14 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

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

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

@@ -1,8 +0,0 @@
-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

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

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

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

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

@@ -1,13 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

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

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

@@ -1,23 +0,0 @@
-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

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

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

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

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

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

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

@@ -1,8 +0,0 @@
-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,10 +0,0 @@
-import { LooseModelDefinition } from "../loose/LooseModelDefinition";
-import { ColumnName } from "./ColumnName";
-import { Columns } from "./Columns";
-
-export type IsSerial<
-    Model extends LooseModelDefinition,
-    C extends ColumnName<Model>,
-> = Columns<Model>[C]["type"] extends "serial" | "bigserial" | "smallserial"
-    ? true
-    : false;

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

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