@casekit/orm2-config 0.0.1 → 1.0.1

package/{src/index.ts → build/index.d.ts}

@@ -6,12 +6,6 @@ export type { NormalizedFieldDefinition } from "./types/NormalizedFieldDefinitio
 export type { NormalizedForeignKeyDefinition } from "./types/NormalizedForeignKeyDefinition.js";
 export type { NormalizedModelDefinition } from "./types/NormalizedModelDefinition.js";
 export type { NormalizedPrimaryKey } from "./types/NormalizedPrimaryKey.js";
-export type {
-    NormalizedManyToManyRelationDefinition,
-    NormalizedManyToOneRelationDefinition,
-    NormalizedOneToManyRelationDefinition,
-    NormalizedRelationDefinition,
-} from "./types/NormalizedRelationDefinition.js";
+export type { NormalizedManyToManyRelationDefinition, NormalizedManyToOneRelationDefinition, NormalizedOneToManyRelationDefinition, NormalizedRelationDefinition, } from "./types/NormalizedRelationDefinition.js";
 export type { NormalizedUniqueConstraintDefinition } from "./types/NormalizedUniqueConstraintDefinition.js";
-
 export { getField, getModel, getRelation } from "./util.js";

package/build/index.js

@@ -0,0 +1,4 @@
+export { normalizeConfig } from "./normalize/normalizeConfig.js";
+export { normalizeModel } from "./normalize/normalizeModel.js";
+export { normalizeUniqueConstraint } from "./normalize/normalizeUniqueConstraints.js";
+export { getField, getModel, getRelation } from "./util.js";

package/build/normalize/defaultZodSchema.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+/**
+ * WARNING!!! The schemas in this file must be kept in sync
+ * with DefaultFieldType in packages/orm-schema/src/helper/DefaultFieldType.ts.
+ * If you make a change here, make sure to update the
+ * corresponding type.
+ */
+export declare const defaultZodSchema: (type: string) => z.ZodType;

package/{src/normalize/defaultZodSchema.ts → build/normalize/defaultZodSchema.js}

@@ -1,26 +1,37 @@
 import { z } from "zod";
-
 /**
  * WARNING!!! The schemas in this file must be kept in sync
  * with DefaultFieldType in packages/orm-schema/src/helper/DefaultFieldType.ts.
  * If you make a change here, make sure to update the
  * corresponding type.
  */
-export const defaultZodSchema = (type: string): z.ZodType => {
+export const defaultZodSchema = (type) => {
     if (type.endsWith("[]"))
         return z.array(defaultZodSchema(type.slice(0, -2)));
-    if (type.startsWith("bit ")) return z.string();
-    if (type.startsWith("bit(")) return z.string();
-    if (type.startsWith("character varying")) return z.string();
-    if (type.startsWith("character")) return z.string();
-    if (type.startsWith("numeric ")) return z.string();
-    if (type.startsWith("numeric(")) return z.string();
-    if (type.startsWith("timestamp ")) return z.date();
-    if (type.startsWith("timestamp(")) return z.date();
-    if (type.startsWith("time ")) return z.string();
-    if (type.startsWith("time(")) return z.string();
-    if (type.startsWith("varchar ")) return z.string();
-    if (type.startsWith("varchar(")) return z.string();
+    if (type.startsWith("bit "))
+        return z.string();
+    if (type.startsWith("bit("))
+        return z.string();
+    if (type.startsWith("character varying"))
+        return z.string();
+    if (type.startsWith("character"))
+        return z.string();
+    if (type.startsWith("numeric "))
+        return z.string();
+    if (type.startsWith("numeric("))
+        return z.string();
+    if (type.startsWith("timestamp "))
+        return z.date();
+    if (type.startsWith("timestamp("))
+        return z.date();
+    if (type.startsWith("time "))
+        return z.string();
+    if (type.startsWith("time("))
+        return z.string();
+    if (type.startsWith("varchar "))
+        return z.string();
+    if (type.startsWith("varchar("))
+        return z.string();
     // if (type.startsWith("interval"))
     //     return z.object({
     //         years: z.number().optional(),
@@ -31,7 +42,6 @@ export const defaultZodSchema = (type: string): z.ZodType => {
     //         seconds: z.number().optional(),
     //         milliseconds: z.number().optional(),
     //     });
-
     switch (type) {
         case "bigint":
         case "bigserial":
@@ -110,10 +120,8 @@ export const defaultZodSchema = (type: string): z.ZodType => {
         case "timestamptz":
             return z.date();
         default:
-            throw new Error(
-                "Unsupported type: " +
-                    type +
-                    " - please specify a zod schema in the field definition",
-            );
+            throw new Error("Unsupported type: " +
+                type +
+                " - please specify a zod schema in the field definition");
     }
 };

package/build/normalize/defaultZodSchema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/{src/normalize/defaultZodSchema.test.ts → build/normalize/defaultZodSchema.test.js}

@@ -1,24 +1,18 @@
 import pg from "pg";
 import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
-
 import { defaultZodSchema } from "./defaultZodSchema.js";
-
 describe("defaultZodSchema", () => {
-    let db: pg.Client;
-
+    let db;
     beforeAll(async () => {
         db = new pg.Client();
         await db.connect();
     });
-
     afterEach(async () => {
         await db.query("ROLLBACK");
     });
-
     afterAll(async () => {
         await db.end();
     });
-
     test.for([
         ["char", "a", "a"],
         ["character", "a", "a"],
@@ -141,20 +135,18 @@ describe("defaultZodSchema", () => {
                 ],
             ],
         ],
-    ] as const)("%s columns", async ([datatype, value, expected = value]) => {
+    ])("%s columns", async ([datatype, value, expected = value]) => {
         await db.query("BEGIN TRANSACTION");
         await db.query(`CREATE TABLE foo (value ${datatype})`);
-
         if (datatype.endsWith("serial")) {
             await db.query("INSERT INTO foo DEFAULT VALUES");
-        } else {
+        }
+        else {
             await db.query(`INSERT INTO foo (value) VALUES ($1::${datatype})`, [
                 value,
             ]);
         }
-
-        const result = await db.query<{ value: unknown }>(`SELECT * FROM foo`);
-
+        const result = await db.query(`SELECT * FROM foo`);
         const parsed = defaultZodSchema(datatype).parse(result.rows[0]?.value);
         expect(parsed).toEqual(expected);
     });

package/build/normalize/getColumns.d.ts

@@ -0,0 +1,2 @@
+import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
+export declare const getColumns: (model: PopulatedModelDefinition, fields: string[]) => string[];

package/{src/normalize/getColumns.ts → build/normalize/getColumns.js}

@@ -1,9 +1,4 @@
-import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
-
-export const getColumns = (
-    model: PopulatedModelDefinition,
-    fields: string[],
-): string[] => {
+export const getColumns = (model, fields) => {
     return fields.map((f) => {
         if (!model.fields[f]) {
             throw new Error(`Field "${f}" not found in model "${model.name}"`);

package/build/normalize/getColumns.test.d.ts

@@ -0,0 +1 @@
+export {};

package/{src/normalize/getColumns.test.ts → build/normalize/getColumns.test.js}

@@ -1,9 +1,7 @@
 import { snakeCase } from "es-toolkit";
 import { describe, expect, test } from "vitest";
-
 import { getColumns } from "./getColumns.js";
 import { populateModels } from "./populateModels.js";
-
 describe("getColumns", () => {
     test("returns column names for given fields", () => {
         const models = populateModels({
@@ -18,12 +16,8 @@ describe("getColumns", () => {
                 },
             },
         });
-
-        expect(
-            getColumns(models["user"]!, ["id", "fullName", "emailAddress"]),
-        ).toEqual(["id", "full_name", "email_address"]);
+        expect(getColumns(models["user"], ["id", "fullName", "emailAddress"])).toEqual(["id", "full_name", "email_address"]);
     });
-
     test("throws error for non-existent field", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -35,12 +29,8 @@ describe("getColumns", () => {
                 },
             },
         });
-
-        expect(() =>
-            getColumns(models["user"]!, ["id", "nonexistent"]),
-        ).toThrow('Field "nonexistent" not found in model "user"');
+        expect(() => getColumns(models["user"], ["id", "nonexistent"])).toThrow('Field "nonexistent" not found in model "user"');
     });
-
     test("returns empty array for empty fields array", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -52,10 +42,8 @@ describe("getColumns", () => {
                 },
             },
         });
-
-        expect(getColumns(models["user"]!, [])).toEqual([]);
+        expect(getColumns(models["user"], [])).toEqual([]);
     });
-
     test("handles custom column names", () => {
         const models = populateModels({
             models: {
@@ -67,8 +55,7 @@ describe("getColumns", () => {
                 },
             },
         });
-
-        expect(getColumns(models["user"]!, ["id", "name"])).toEqual([
+        expect(getColumns(models["user"], ["id", "name"])).toEqual([
             "id",
             "user_full_name",
         ]);

package/build/normalize/normalizeConfig.d.ts

@@ -0,0 +1,3 @@
+import { Config } from "@casekit/orm2-schema";
+import { NormalizedConfig } from "#types/NormalizedConfig.js";
+export declare const normalizeConfig: (config: Config) => NormalizedConfig;

package/{src/normalize/normalizeConfig.ts → build/normalize/normalizeConfig.js}

@@ -1,12 +1,7 @@
 import { identity, mapValues } from "es-toolkit";
-
-import { Config } from "@casekit/orm2-schema";
-
-import { NormalizedConfig } from "#types/NormalizedConfig.js";
 import { normalizeModel } from "./normalizeModel.js";
 import { populateModels } from "./populateModels.js";
-
-export const normalizeConfig = (config: Config): NormalizedConfig => {
+export const normalizeConfig = (config) => {
     const models = populateModels(config);
     return {
         ...config,

package/build/normalize/normalizeConfig.test.d.ts

@@ -0,0 +1 @@
+export {};

package/{src/normalize/normalizeConfig.test.ts → build/normalize/normalizeConfig.test.js}

@@ -1,11 +1,8 @@
 import { snakeCase } from "es-toolkit";
 import { describe, expect, test } from "vitest";
 import { z } from "zod";
-
 import { sql } from "@casekit/sql";
-
 import { normalizeConfig } from "./normalizeConfig.js";
-
 describe("normalizeConfig", () => {
     test("normalizes minimal config with defaults", () => {
         const config = {
@@ -17,10 +14,8 @@ describe("normalizeConfig", () => {
                     },
                 },
             },
-        } as const;
-
+        };
         const result = normalizeConfig(config);
-
         expect(result.schema).toBe("public");
         expect(result.operators).toEqual({ where: {} });
         expect(result.extensions).toEqual([]);
@@ -29,12 +24,10 @@ describe("normalizeConfig", () => {
         expect(result.logger).toBe(console);
         expect(typeof result.naming.column).toBe("function");
         expect(typeof result.naming.table).toBe("function");
-
         // Test that default identity functions don't transform names
         expect(result.naming.column("userName")).toBe("userName");
         expect(result.naming.table("UserProfile")).toBe("UserProfile");
     });
-
     test("preserves provided config values", () => {
         const customLogger = {
             debug: () => {
@@ -50,9 +43,7 @@ describe("normalizeConfig", () => {
                 /* empty */
             },
         };
-
         const $contains = Symbol("contains");
-
         const config = {
             schema: "custom",
             models: {
@@ -64,7 +55,7 @@ describe("normalizeConfig", () => {
             },
             operators: {
                 where: {
-                    [$contains]: () => sql``,
+                    [$contains]: () => sql ``,
                 },
             },
             extensions: ["uuid-ossp"],
@@ -78,10 +69,8 @@ describe("normalizeConfig", () => {
                 column: snakeCase,
                 table: snakeCase,
             },
-        } as const;
-
+        };
         const result = normalizeConfig(config);
-
         expect(result.schema).toBe("custom");
         expect(result.operators).toBe(config.operators);
         expect(result.extensions).toEqual(["uuid-ossp"]);
@@ -91,7 +80,6 @@ describe("normalizeConfig", () => {
         expect(result.naming.column).toBe(snakeCase);
         expect(result.naming.table).toBe(snakeCase);
     });
-
     test("normalizes models with relationships", () => {
         const config = {
             models: {
@@ -102,7 +90,7 @@ describe("normalizeConfig", () => {
                     },
                     relations: {
                         posts: {
-                            type: "1:N" as const,
+                            type: "1:N",
                             model: "post",
                             fromField: "id",
                             toField: "authorId",
@@ -116,11 +104,9 @@ describe("normalizeConfig", () => {
                     },
                 },
             },
-        } as const;
-
+        };
         const result = normalizeConfig(config);
-
-        expect(result.models["user"]!.relations["posts"]!).toEqual({
+        expect(result.models["user"].relations["posts"]).toEqual({
             name: "posts",
             type: "1:N",
             model: "post",
@@ -135,7 +121,6 @@ describe("normalizeConfig", () => {
             },
         });
     });
-
     test("applies naming functions to all models", () => {
         const config = {
             naming: {
@@ -158,37 +143,20 @@ describe("normalizeConfig", () => {
                     },
                 },
             },
-        } as const;
-
+        };
         const result = normalizeConfig(config);
-
         // Check table names
-        expect(result.models["userProfile"]!.table).toBe("user_profile");
-        expect(result.models["orderItem"]!.table).toBe("order_item");
-
+        expect(result.models["userProfile"].table).toBe("user_profile");
+        expect(result.models["orderItem"].table).toBe("order_item");
         // Check column names in first model
-        expect(result.models["userProfile"]!.fields["userId"]!.column).toBe(
-            "user_id",
-        );
-        expect(result.models["userProfile"]!.fields["firstName"]!.column).toBe(
-            "first_name",
-        );
-        expect(result.models["userProfile"]!.fields["lastName"]!.column).toBe(
-            "last_name",
-        );
-
+        expect(result.models["userProfile"].fields["userId"].column).toBe("user_id");
+        expect(result.models["userProfile"].fields["firstName"].column).toBe("first_name");
+        expect(result.models["userProfile"].fields["lastName"].column).toBe("last_name");
         // Check column names in second model
-        expect(result.models["orderItem"]!.fields["orderId"]!.column).toBe(
-            "order_id",
-        );
-        expect(result.models["orderItem"]!.fields["productId"]!.column).toBe(
-            "product_id",
-        );
-        expect(result.models["orderItem"]!.fields["unitPrice"]!.column).toBe(
-            "unit_price",
-        );
+        expect(result.models["orderItem"].fields["orderId"].column).toBe("order_id");
+        expect(result.models["orderItem"].fields["productId"].column).toBe("product_id");
+        expect(result.models["orderItem"].fields["unitPrice"].column).toBe("unit_price");
     });
-
     test("normalizes custom Zod schemas in models", () => {
         const config = {
             models: {
@@ -206,19 +174,12 @@ describe("normalizeConfig", () => {
                     },
                 },
             },
-        } as const;
-
+        };
         const result = normalizeConfig(config);
-
         // Verify that Zod schemas are preserved
-        expect(
-            result.models["user"]!.fields["email"]!.zodSchema,
-        ).toBeInstanceOf(z.ZodEmail);
-        expect(result.models["user"]!.fields["age"]!.zodSchema).toBeInstanceOf(
-            z.ZodNumber,
-        );
+        expect(result.models["user"].fields["email"].zodSchema).toBeInstanceOf(z.ZodEmail);
+        expect(result.models["user"].fields["age"].zodSchema).toBeInstanceOf(z.ZodNumber);
     });
-
     test("handles partial naming configuration", () => {
         const config = {
             naming: {
@@ -232,18 +193,13 @@ describe("normalizeConfig", () => {
                     },
                 },
             },
-        } as const;
-
+        };
         const result = normalizeConfig(config);
-
         // Column should be transformed
-        expect(result.models["userProfile"]!.fields["userId"]!.column).toBe(
-            "user_id",
-        );
+        expect(result.models["userProfile"].fields["userId"].column).toBe("user_id");
         // Table should remain unchanged due to default identity function
-        expect(result.models["userProfile"]!.table).toBe("userProfile");
+        expect(result.models["userProfile"].table).toBe("userProfile");
     });
-
     test("handles empty extensions array", () => {
         const config = {
             models: {
@@ -254,10 +210,8 @@ describe("normalizeConfig", () => {
                 },
             },
             extensions: [],
-        } as const;
-
+        };
         const result = normalizeConfig(config);
-
         expect(result.extensions).toEqual([]);
     });
 });

package/build/normalize/normalizeField.d.ts

@@ -0,0 +1,3 @@
+import { NormalizedFieldDefinition } from "#types/NormalizedFieldDefinition.js";
+import { PopulatedFieldDefinition } from "#types/PopulatedFieldDefinition.js";
+export declare const normalizeField: (field: PopulatedFieldDefinition) => NormalizedFieldDefinition;

package/build/normalize/normalizeField.js

@@ -0,0 +1,11 @@
+export const normalizeField = (field) => {
+    return {
+        name: field.name,
+        column: field.column,
+        type: field.type,
+        zodSchema: field.zodSchema,
+        nullable: field.nullable,
+        default: field.default,
+        provided: field.provided,
+    };
+};

package/build/normalize/normalizeField.test.d.ts

@@ -0,0 +1 @@
+export {};

package/{src/normalize/normalizeField.test.ts → build/normalize/normalizeField.test.js}

@@ -1,10 +1,8 @@
 import { snakeCase } from "es-toolkit";
 import { describe, expect, test } from "vitest";
 import { ZodType } from "zod";
-
 import { normalizeField } from "./normalizeField.js";
 import { populateModels } from "./populateModels.js";
-
 describe("normalizeField", () => {
     test("strips out references, unique, and primary key properties", () => {
         const models = populateModels({
@@ -30,8 +28,7 @@ describe("normalizeField", () => {
                 },
             },
         });
-
-        expect(normalizeField(models["post"]!.fields["id"]!)).toEqual({
+        expect(normalizeField(models["post"].fields["id"])).toEqual({
             name: "id",
             column: "id",
             type: "serial",
@@ -40,8 +37,7 @@ describe("normalizeField", () => {
             default: null,
             provided: false,
         });
-
-        expect(normalizeField(models["post"]!.fields["slug"]!)).toEqual({
+        expect(normalizeField(models["post"].fields["slug"])).toEqual({
             name: "slug",
             column: "slug",
             type: "text",
@@ -50,8 +46,7 @@ describe("normalizeField", () => {
             default: null,
             provided: false,
         });
-
-        expect(normalizeField(models["post"]!.fields["authorId"]!)).toEqual({
+        expect(normalizeField(models["post"].fields["authorId"])).toEqual({
             name: "authorId",
             column: "author_id",
             type: "integer",

package/build/normalize/normalizeForeignKeys.d.ts

@@ -0,0 +1,5 @@
+import { ForeignKeyDefinition } from "@casekit/orm2-schema";
+import { NormalizedForeignKeyDefinition } from "#types/NormalizedForeignKeyDefinition.js";
+import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
+export declare const normalizeForeignKeys: (models: Record<string, PopulatedModelDefinition>, model: PopulatedModelDefinition) => NormalizedForeignKeyDefinition[];
+export declare const normalizeForeignKey: (models: Record<string, PopulatedModelDefinition>, model: PopulatedModelDefinition, fk: ForeignKeyDefinition) => NormalizedForeignKeyDefinition;

package/build/normalize/normalizeForeignKeys.js

@@ -0,0 +1,50 @@
+import { isEqual } from "es-toolkit";
+import { getColumns } from "./getColumns.js";
+export const normalizeForeignKeys = (models, model) => {
+    const columnLevelForeignKeys = Object.values(model.fields)
+        .filter(hasReference)
+        .map(referenceToForeignKey)
+        .map((fk) => normalizeForeignKey(models, model, fk));
+    const modelLevelForeignKeys = model.foreignKeys.map((fk) => normalizeForeignKey(models, model, fk));
+    for (const fk of columnLevelForeignKeys) {
+        if (modelLevelForeignKeys.some((other) => isEqual(fk.columns, other.columns))) {
+            throw new Error(`Duplicate foreign key defined in model "${model.name}"`);
+        }
+    }
+    return [...columnLevelForeignKeys, ...modelLevelForeignKeys];
+};
+export const normalizeForeignKey = (models, model, fk) => {
+    const referencedModel = models[fk.references.model];
+    if (!referencedModel) {
+        throw new Error(`Referenced model "${fk.references.model}" not found in models`);
+    }
+    const columns = getColumns(model, fk.fields);
+    return {
+        name: fk.name ?? [model.table, ...columns, "fkey"].join("_"),
+        fields: fk.fields,
+        columns: columns,
+        references: {
+            model: fk.references.model,
+            fields: fk.references.fields,
+            schema: referencedModel.schema,
+            table: referencedModel.table,
+            columns: getColumns(referencedModel, fk.references.fields),
+        },
+        onUpdate: fk.onUpdate ?? null,
+        onDelete: fk.onDelete ?? null,
+    };
+};
+const referenceToForeignKey = (field) => {
+    return {
+        fields: [field.name],
+        references: {
+            model: field.references.model,
+            fields: [field.references.field],
+        },
+        onUpdate: field.references.onUpdate,
+        onDelete: field.references.onDelete,
+    };
+};
+const hasReference = (field) => {
+    return !!field.references;
+};

package/build/normalize/normalizeForeignKeys.test.d.ts

@@ -0,0 +1 @@
+export {};