@casekit/orm2-schema 1.0.0 → 1.0.1

package/{src/helper/NullableField.test-d.ts → build/helper/NullableField.test-d.js}

@@ -1,8 +1,4 @@
 import { describe, expectTypeOf, test } from "vitest";
-
-import type { ModelDefinition } from "../definition/ModelDefinition.js";
-import type { NullableField } from "./NullableField.js";
-
 describe("NullableField", () => {
     test("extracts just the nullable fields from the model", () => {
         const user = {
@@ -12,13 +8,9 @@ describe("NullableField", () => {
                 email: { type: "text", nullable: true },
                 age: { type: "integer", nullable: false },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<NullableField<typeof user>>().toEqualTypeOf<
-            "name" | "email"
-        >();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
-
     test("returns never if there are no nullable fields", () => {
         const user = {
             fields: {
@@ -26,11 +18,9 @@ describe("NullableField", () => {
                 name: { type: "text", nullable: false },
                 age: { type: "integer", nullable: false },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<NullableField<typeof user>>().toEqualTypeOf<never>();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
-
     test("treats fields without nullable property as non-nullable", () => {
         const user = {
             fields: {
@@ -38,8 +28,7 @@ describe("NullableField", () => {
                 name: { type: "text", nullable: true },
                 age: { type: "integer" },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<NullableField<typeof user>>().toEqualTypeOf<"name">();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
 });

package/{src/helper/OptionalField.ts → build/helper/OptionalField.d.ts}

@@ -1,8 +1,4 @@
 import { ModelDefinition } from "#definition/ModelDefinition.js";
 import { FieldName } from "./FieldName.js";
 import { RequiredField } from "./RequiredField.js";
-
-export type OptionalField<Model extends ModelDefinition> = Exclude<
-    FieldName<Model>,
-    RequiredField<Model>
->;
+export type OptionalField<Model extends ModelDefinition> = Exclude<FieldName<Model>, RequiredField<Model>>;

package/build/helper/OptionalField.js

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

package/build/helper/OptionalField.test-d.d.ts

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

package/{src/helper/OptionalField.test-d.ts → build/helper/OptionalField.test-d.js}

@@ -1,8 +1,4 @@
 import { describe, expectTypeOf, test } from "vitest";
-
-import type { ModelDefinition } from "../definition/ModelDefinition.js";
-import type { OptionalField } from "./OptionalField.js";
-
 describe("OptionalField", () => {
     test("extracts fields that are optional for insert", () => {
         const user = {
@@ -13,13 +9,9 @@ describe("OptionalField", () => {
                 age: { type: "integer", nullable: false, default: 18 },
                 role: { type: "text", nullable: false, provided: true },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<OptionalField<typeof user>>().toEqualTypeOf<
-            "id" | "age" | "role"
-        >();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
-
     test("returns all fields if none are required", () => {
         const user = {
             fields: {
@@ -28,13 +20,9 @@ describe("OptionalField", () => {
                 age: { type: "integer", default: 18 },
                 role: { type: "text", provided: true },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<OptionalField<typeof user>>().toEqualTypeOf<
-            "id" | "name" | "age" | "role"
-        >();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
-
     test("includes fields with defaults, serial fields, nullable fields and provided fields", () => {
         const user = {
             fields: {
@@ -45,10 +33,7 @@ describe("OptionalField", () => {
                 role: { type: "text", provided: true },
                 score: { type: "integer", nullable: false },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<OptionalField<typeof user>>().toEqualTypeOf<
-            "id" | "email" | "age" | "role"
-        >();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
 });

package/{src/helper/ProvidedField.ts → build/helper/ProvidedField.d.ts}

@@ -1,7 +1,4 @@
 import { ModelDefinition } from "../definition/ModelDefinition.js";
-
 export type ProvidedField<Model extends ModelDefinition> = {
-    [K in keyof Model["fields"]]: Model["fields"][K]["provided"] extends true
-        ? K
-        : never;
+    [K in keyof Model["fields"]]: Model["fields"][K]["provided"] extends true ? K : never;
 }[keyof Model["fields"]];

package/build/helper/ProvidedField.js

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

package/build/helper/ProvidedField.test-d.d.ts

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

package/{src/helper/ProvidedField.test-d.ts → build/helper/ProvidedField.test-d.js}

@@ -1,8 +1,4 @@
 import { describe, expectTypeOf, test } from "vitest";
-
-import type { ModelDefinition } from "../definition/ModelDefinition.js";
-import type { ProvidedField } from "./ProvidedField.js";
-
 describe("ProvidedField", () => {
     test("extracts just the provided fields from the model", () => {
         const user = {
@@ -12,13 +8,9 @@ describe("ProvidedField", () => {
                 updatedAt: { type: "timestamp", provided: true },
                 name: { type: "text", provided: false },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<ProvidedField<typeof user>>().toEqualTypeOf<
-            "createdAt" | "updatedAt"
-        >();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
-
     test("returns never if there are no provided fields", () => {
         const user = {
             fields: {
@@ -26,11 +18,9 @@ describe("ProvidedField", () => {
                 name: { type: "text", provided: false },
                 age: { type: "integer", provided: false },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<ProvidedField<typeof user>>().toEqualTypeOf<never>();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
-
     test("treats fields without provided property as non-provided", () => {
         const user = {
             fields: {
@@ -38,8 +28,7 @@ describe("ProvidedField", () => {
                 createdAt: { type: "timestamp", provided: true },
                 name: { type: "text" },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<ProvidedField<typeof user>>().toEqualTypeOf<"createdAt">();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
 });

package/build/helper/RelationModel.d.ts

@@ -0,0 +1,4 @@
+import { ModelDefinitions } from "#definition/ModelDefinitions.js";
+import { ModelName } from "./ModelName.js";
+import { RelationName } from "./RelationName.js";
+export type RelationModel<Models extends ModelDefinitions, M extends ModelName<Models>, R extends RelationName<Models[M]>> = Models[NonNullable<Models[M]["relations"]>[R]["model"]];

package/build/helper/RelationModel.js

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

package/build/helper/RelationModel.test-d.d.ts

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

package/{src/helper/RelationModel.test-d.ts → build/helper/RelationModel.test-d.js}

@@ -1,8 +1,4 @@
 import { describe, expectTypeOf, test } from "vitest";
-
-import { ModelDefinitions } from "../definition/ModelDefinitions.js";
-import { RelationModel } from "./RelationModel.js";
-
 describe("RelationModel", () => {
     const models = {
         user: {
@@ -43,39 +39,22 @@ describe("RelationModel", () => {
             },
         },
         like: { fields: {} },
-    } as const satisfies ModelDefinitions;
-
+    };
     test("looks up the correct relation model in the schema for N:1 relations", () => {
-        expectTypeOf<RelationModel<typeof models, "post", "author">>().toExtend<
-            typeof models.user
-        >();
+        expectTypeOf().toExtend();
     });
-
     test("looks up the correct relation model in the schema for 1:N relations", () => {
-        expectTypeOf<RelationModel<typeof models, "post", "likes">>().toExtend<
-            typeof models.like
-        >();
+        expectTypeOf().toExtend();
     });
-
     test("looks up the correct relation model in the schema for N:N relations", () => {
-        expectTypeOf<
-            RelationModel<typeof models, "user", "likedPosts">
-        >().toExtend<typeof models.post>();
+        expectTypeOf().toExtend();
     });
-
     describe("errors", () => {
         test("looking up a non-existing relation causes an error", () => {
-            expectTypeOf<
-                // @ts-expect-error relation does not exist
-                RelationModel<typeof models, "post", "posts">
-            >().not.toExtend<typeof models.post>();
+            expectTypeOf().not.toExtend();
         });
-
         test("looking up a relation for a model that doesn't exist causes an error", () => {
-            expectTypeOf<
-                // @ts-expect-error model does not exist
-                RelationModel<typeof models, "postx", "posts">
-            >().not.toExtend<typeof models.post>();
+            expectTypeOf().not.toExtend();
         });
     });
 });

package/build/helper/RelationName.d.ts

@@ -0,0 +1,2 @@
+import { ModelDefinition } from "#definition/ModelDefinition.js";
+export type RelationName<Model extends ModelDefinition> = keyof Model["relations"];

package/build/helper/RelationName.js

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

package/build/helper/RelationName.test-d.d.ts

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

package/{src/helper/RelationName.test-d.ts → build/helper/RelationName.test-d.js}

@@ -1,8 +1,4 @@
 import { describe, expectTypeOf, test } from "vitest";
-
-import { ModelDefinition } from "../definition/ModelDefinition.js";
-import { RelationName } from "./RelationName.js";
-
 describe("RelationName", () => {
     test("it evaluates to a string union of the names of the model's relations", () => {
         const user = {
@@ -24,12 +20,8 @@ describe("RelationName", () => {
                     },
                 },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<RelationName<typeof user>>().toEqualTypeOf<
-            "posts" | "friends"
-        >();
-
+        };
+        expectTypeOf().toEqualTypeOf();
         const post = {
             fields: { id: { type: "serial" } },
             relations: {
@@ -46,9 +38,7 @@ describe("RelationName", () => {
                     toField: "postId",
                 },
             },
-        } as const satisfies ModelDefinition;
-        expectTypeOf<RelationName<typeof post>>().toEqualTypeOf<
-            "author" | "likes"
-        >();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
 });

package/{src/helper/RequiredField.ts → build/helper/RequiredField.d.ts}

@@ -4,11 +4,4 @@ import { FieldWithDefault } from "./FieldWithDefault.js";
 import { NullableField } from "./NullableField.js";
 import { ProvidedField } from "./ProvidedField.js";
 import { SerialField } from "./SerialField.js";
-
-export type RequiredField<Model extends ModelDefinition> = Exclude<
-    FieldName<Model>,
-    | NullableField<Model>
-    | FieldWithDefault<Model>
-    | SerialField<Model>
-    | ProvidedField<Model>
->;
+export type RequiredField<Model extends ModelDefinition> = Exclude<FieldName<Model>, NullableField<Model> | FieldWithDefault<Model> | SerialField<Model> | ProvidedField<Model>>;

package/build/helper/RequiredField.js

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

package/build/helper/RequiredField.test-d.d.ts

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

package/{src/helper/RequiredField.test-d.ts → build/helper/RequiredField.test-d.js}

@@ -1,8 +1,4 @@
 import { describe, expectTypeOf, test } from "vitest";
-
-import type { ModelDefinition } from "../definition/ModelDefinition.js";
-import type { RequiredField } from "./RequiredField.js";
-
 describe("RequiredField", () => {
     test("extracts fields that are required for insert", () => {
         const user = {
@@ -13,13 +9,9 @@ describe("RequiredField", () => {
                 age: { type: "integer", nullable: false, default: 18 },
                 role: { type: "text", nullable: false, provided: true },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<RequiredField<typeof user>>().toEqualTypeOf<
-            "name" | "email"
-        >();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
-
     test("returns never if all fields are optional", () => {
         const user = {
             fields: {
@@ -28,11 +20,9 @@ describe("RequiredField", () => {
                 age: { type: "integer", default: 18 },
                 role: { type: "text", provided: true },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<RequiredField<typeof user>>().toEqualTypeOf<never>();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
-
     test("excludes fields with defaults, serial fields, nullable fields and provided fields", () => {
         const user = {
             fields: {
@@ -43,10 +33,7 @@ describe("RequiredField", () => {
                 role: { type: "text", provided: true },
                 score: { type: "integer", nullable: false },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<RequiredField<typeof user>>().toEqualTypeOf<
-            "name" | "score"
-        >();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
 });

package/{src/helper/SerialField.ts → build/helper/SerialField.d.ts}

@@ -1,10 +1,4 @@
 import { ModelDefinition } from "../definition/ModelDefinition.js";
-
 export type SerialField<Model extends ModelDefinition> = {
-    [K in keyof Model["fields"]]: Uppercase<Model["fields"][K]["type"]> extends
-        | "SMALLSERIAL"
-        | "SERIAL"
-        | "BIGSERIAL"
-        ? K
-        : never;
+    [K in keyof Model["fields"]]: Uppercase<Model["fields"][K]["type"]> extends "SMALLSERIAL" | "SERIAL" | "BIGSERIAL" ? K : never;
 }[keyof Model["fields"]];

package/build/helper/SerialField.js

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

package/build/helper/SerialField.test-d.d.ts

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

package/{src/helper/SerialField.test-d.ts → build/helper/SerialField.test-d.js}

@@ -1,8 +1,4 @@
 import { describe, expectTypeOf, test } from "vitest";
-
-import type { ModelDefinition } from "../definition/ModelDefinition.js";
-import type { SerialField } from "./SerialField.js";
-
 describe("SerialField", () => {
     test("extracts just the fields with a SERIAL datatype from the model", () => {
         const user = {
@@ -13,13 +9,9 @@ describe("SerialField", () => {
                 name: { type: "text" },
                 age: { type: "integer" },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<SerialField<typeof user>>().toEqualTypeOf<
-            "id" | "smallId" | "bigId"
-        >();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
-
     test("works for both lower and uppercase field types", () => {
         const user = {
             fields: {
@@ -29,24 +21,18 @@ describe("SerialField", () => {
                 name: { type: "TEXT" },
                 age: { type: "INTEGER" },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<SerialField<typeof user>>().toEqualTypeOf<
-            "id" | "smallId" | "bigId"
-        >();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
-
     test("returns never if there are no SERIAL fields", () => {
         const user = {
             fields: {
                 name: { type: "text" },
                 age: { type: "integer" },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<SerialField<typeof user>>().toEqualTypeOf<never>();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
-
     test("does not include fields with a type that end with serial but isn't a serial type", () => {
         const user = {
             fields: {
@@ -54,8 +40,7 @@ describe("SerialField", () => {
                 name: { type: "text" },
                 age: { type: "integer" },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<SerialField<typeof user>>().toEqualTypeOf<"id">();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
 });

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

@@ -4,16 +4,10 @@ export type { ModelDefinition } from "./definition/ModelDefinition.js";
 export type { ModelDefinitions } from "./definition/ModelDefinitions.js";
 export type { OperatorDefinitions } from "./definition/OperatorDefinitions.js";
 export type { PostgresDataTypes } from "./definition/PostgresDataTypes.js";
-export type {
-    ManyToManyRelationDefinition,
-    ManyToOneRelationDefinition,
-    OneToManyRelationDefinition,
-    RelationDefinition,
-} from "./definition/RelationDefinition.js";
+export type { ManyToManyRelationDefinition, ManyToOneRelationDefinition, OneToManyRelationDefinition, RelationDefinition, } from "./definition/RelationDefinition.js";
 export type { RelationDefinitions } from "./definition/RelationDefinitions.js";
 export type { UniqueConstraintDefinition } from "./definition/UniqueConstraintDefinition.js";
 export type { WhereOperatorDefinition as OperatorDefinition } from "./definition/WhereOperator.js";
-
 export type { DefaultFieldType } from "./helper/DefaultFieldType.js";
 export type { FieldName } from "./helper/FieldName.js";
 export type { FieldType } from "./helper/FieldType.js";
@@ -27,6 +21,5 @@ export type { RelationModel } from "./helper/RelationModel.js";
 export type { RelationName } from "./helper/RelationName.js";
 export type { RequiredField } from "./helper/RequiredField.js";
 export type { SerialField } from "./helper/SerialField.js";
-
 export type { Config } from "./Config.js";
 export type { Logger } from "./Logger.js";

package/build/index.js

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

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@casekit/orm2-schema",
   "description": "",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "author": "",
   "dependencies": {
-    "@casekit/sql": "1.0.0",
-    "@casekit/toolbox": "1.0.0"
+    "@casekit/sql": "1.0.1",
+    "@casekit/toolbox": "1.0.1"
   },
   "devDependencies": {
     "@trivago/prettier-plugin-sort-imports": "^5.2.2",
@@ -18,17 +18,17 @@
     "typescript-eslint": "^8.34.1",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.4",
-    "@casekit/prettier-config": "1.0.0",
-    "@casekit/tsconfig": "1.0.0"
+    "@casekit/tsconfig": "1.0.1",
+    "@casekit/prettier-config": "1.0.1"
   },
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./build/index.js"
   },
   "files": [
-    "/src"
+    "/build"
   ],
   "imports": {
-    "#*": "./src/*"
+    "#*": "./build/*"
   },
   "keywords": [],
   "license": "ISC",

package/src/definition/WhereOperator.ts

@@ -1,6 +0,0 @@
-import { SQLStatement } from "@casekit/sql";
-
-export type WhereOperatorDefinition = (
-    meta: { table: SQLStatement; column: SQLStatement },
-    value: unknown,
-) => SQLStatement;

package/src/helper/DefaultFieldType.test-d.ts

@@ -1,60 +0,0 @@
-import { expectTypeOf, test } from "vitest";
-
-import { DefaultFieldType } from "./DefaultFieldType.js";
-
-test("DefaultFieldType", () => {
-    expectTypeOf<DefaultFieldType<"bigint">>().toBeBigInt();
-    expectTypeOf<DefaultFieldType<"integer">>().toBeNumber();
-    expectTypeOf<DefaultFieldType<"double precision">>().toBeNumber();
-    expectTypeOf<DefaultFieldType<"oid">>().toBeNumber();
-    expectTypeOf<DefaultFieldType<"real">>().toBeNumber();
-    expectTypeOf<DefaultFieldType<"smallint">>().toBeNumber();
-    expectTypeOf<DefaultFieldType<"smallserial">>().toBeNumber();
-    expectTypeOf<DefaultFieldType<"serial">>().toBeNumber();
-    expectTypeOf<DefaultFieldType<"text">>().toBeString();
-    expectTypeOf<DefaultFieldType<"uuid">>().toBeString();
-    expectTypeOf<DefaultFieldType<"bytea">>().toEqualTypeOf<Buffer>();
-    // expectTypeOf<DefaultFieldType<"circle">>().toEqualTypeOf<{
-    //     x: number;
-    //     y: number;
-    //     radius: number;
-    // }>();
-    // expectTypeOf<DefaultFieldType<"point">>().toEqualTypeOf<{
-    //     x: number;
-    //     y: number;
-    // }>();
-    expectTypeOf<DefaultFieldType<"json">>().toBeUnknown();
-    expectTypeOf<DefaultFieldType<"jsonb">>().toBeUnknown();
-    expectTypeOf<DefaultFieldType<"boolean">>().toBeBoolean();
-    expectTypeOf<DefaultFieldType<"date">>().toEqualTypeOf<Date>();
-    expectTypeOf<DefaultFieldType<"timestamp">>().toEqualTypeOf<Date>();
-    // expectTypeOf<DefaultFieldType<"interval">>().toEqualTypeOf<{
-    //     years?: number;
-    //     months?: number;
-    //     days?: number;
-    //     hours?: number;
-    //     minutes?: number;
-    //     seconds?: number;
-    //     milliseconds?: number;
-    // }>();
-    expectTypeOf<DefaultFieldType<"time">>().toEqualTypeOf<string>();
-    expectTypeOf<DefaultFieldType<"timetz">>().toEqualTypeOf<string>();
-    expectTypeOf<DefaultFieldType<"timestamptz">>().toEqualTypeOf<Date>();
-    expectTypeOf<DefaultFieldType<"varchar">>().toBeString();
-    expectTypeOf<DefaultFieldType<"char">>().toBeString();
-    expectTypeOf<DefaultFieldType<"numeric">>().toBeString();
-    expectTypeOf<DefaultFieldType<"decimal">>().toBeString();
-    expectTypeOf<DefaultFieldType<"money">>().toBeString();
-    expectTypeOf<DefaultFieldType<"bit">>().toBeString();
-    expectTypeOf<DefaultFieldType<"box">>().toBeString();
-    expectTypeOf<DefaultFieldType<"line">>().toBeString();
-    expectTypeOf<DefaultFieldType<"lseg">>().toBeString();
-    expectTypeOf<DefaultFieldType<"path">>().toBeString();
-    expectTypeOf<DefaultFieldType<"polygon">>().toBeString();
-    expectTypeOf<DefaultFieldType<"cidr">>().toBeString();
-    expectTypeOf<DefaultFieldType<"inet">>().toBeString();
-    expectTypeOf<DefaultFieldType<"macaddr">>().toBeString();
-    expectTypeOf<DefaultFieldType<"tsquery">>().toBeString();
-    expectTypeOf<DefaultFieldType<"tsvector">>().toBeString();
-    expectTypeOf<DefaultFieldType<"xml">>().toBeString();
-});