@casekit/orm2-schema 0.0.0-20250331202540 → 0.0.1

package/package.json

@@ -1,41 +1,40 @@
 {
   "name": "@casekit/orm2-schema",
   "description": "",
-  "version": "0.0.0-20250331202540",
+  "version": "0.0.1",
   "author": "",
   "dependencies": {
-    "@casekit/sql": "0.0.0-20250331202540",
-    "@casekit/toolbox": "0.0.0-20250331202540"
+    "@casekit/sql": "0.0.1",
+    "@casekit/toolbox": "0.0.1"
   },
   "devDependencies": {
     "@trivago/prettier-plugin-sort-imports": "^5.2.2",
-    "@types/node": "^22.13.13",
-    "@types/pg": "^8.11.11",
+    "@types/node": "^24.0.3",
+    "@types/pg": "^8.15.4",
     "@types/uuid": "^10.0.0",
     "prettier": "^3.5.3",
-    "ts-essentials": "^10.0.4",
-    "typescript": "^5.8.2",
-    "typescript-eslint": "^8.28.0",
+    "ts-essentials": "^10.1.1",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.34.1",
     "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^3.0.9",
-    "@casekit/tsconfig": "0.0.0-20250331202540",
-    "@casekit/prettier-config": "0.0.0-20250331202540"
+    "vitest": "^3.2.4",
+    "@casekit/tsconfig": "0.0.1",
+    "@casekit/prettier-config": "0.0.1"
   },
   "exports": {
-    ".": "./build/index.js"
+    ".": "./src/index.ts"
   },
   "files": [
-    "/build"
+    "/src"
   ],
   "imports": {
-    "#*": "./build/*"
+    "#*": "./src/*"
   },
   "keywords": [],
   "license": "ISC",
-  "main": "index.js",
   "peerDependencies": {
     "pg": "^8.13.1",
-    "zod": "^3.24.2"
+    "zod": "^4.0.17"
   },
   "prettier": "@casekit/prettier-config",
   "type": "module",

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

@@ -1,12 +1,19 @@
 import pg from "pg";
-import { ModelDefinitions, OperatorDefinitions } from "@casekit/orm2-schema";
+
 import { Logger } from "./Logger.js";
+import { ModelDefinitions } from "./definition/ModelDefinitions.js";
+import { OperatorDefinitions } from "./definition/OperatorDefinitions.js";
+
 export interface Config {
     readonly schema?: string;
     readonly models: ModelDefinitions;
     readonly operators?: OperatorDefinitions;
     readonly extensions?: readonly string[];
-    readonly connection?: pg.ConnectionConfig | pg.PoolConfig | pg.PoolOptions | null;
+    readonly connection?:
+        | pg.ConnectionConfig
+        | pg.PoolConfig
+        | pg.PoolOptions
+        | null;
     readonly pool?: boolean;
     readonly logger?: Logger;
     readonly naming?: {

package/{build/definition/FieldDefinition.d.ts → src/definition/FieldDefinition.ts}

@@ -1,6 +1,9 @@
 import { z } from "zod";
+
 import { SQLStatement } from "@casekit/sql";
+
 import { PostgresDataTypes } from "./PostgresDataTypes.js";
+
 export interface FieldDefinition {
     /**
      * The name of the column in the database. If not specified,
@@ -9,10 +12,14 @@ export interface FieldDefinition {
      * in the config applied.
      */
     column?: string;
+
     /**
      * The postgresql datatype of the column.
      */
-    type: `${PostgresDataTypes[keyof PostgresDataTypes]}${string}` | `${Uppercase<PostgresDataTypes[keyof PostgresDataTypes]>}${string}`;
+    type:
+        | `${PostgresDataTypes[keyof PostgresDataTypes]}${string}` // the string at the end allows for arrays
+        | `${Uppercase<PostgresDataTypes[keyof PostgresDataTypes]>}${string}`;
+
     /**
      * A Zod schema used to infer the type of the column and to
      * validate/transform data coming from the database.
@@ -21,11 +28,13 @@ export interface FieldDefinition {
      * allows to you configure more sophisticated parsing, validation,
      * and transformations.
      */
-    zodSchema?: z.ZodType<unknown>;
+    zodSchema?: z.ZodType;
+
     /**
      * Are null values allowed in this column?
      */
     nullable?: boolean;
+
     /**
      * The default value for this column, if it has one. This can be either a value such
      * as a number or string, or if you want to specify a SQL function for the default,
@@ -42,19 +51,21 @@ export interface FieldDefinition {
      * default: sql`uuid_generate_v4()`,
      */
     default?: unknown;
+
     /**
      * 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 | null;
-        nullsNotDistinct?: boolean;
-    };
+    unique?:
+        | boolean
+        | { where?: SQLStatement | null; 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.
@@ -66,9 +77,11 @@ export interface FieldDefinition {
         onUpdate?: "RESTRICT" | "CASCADE" | "SET NULL" | "SET DEFAULT" | null;
         onDelete?: "RESTRICT" | "CASCADE" | "SET NULL" | "SET DEFAULT" | null;
     } | null;
+
     /**
      * 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/{build/definition/ModelDefinition.d.ts → src/definition/ModelDefinition.ts}

@@ -2,6 +2,7 @@ import { FieldDefinition } from "./FieldDefinition.js";
 import { ForeignKeyDefinition } from "./ForeignKeyDefinition.js";
 import { RelationDefinitions } from "./RelationDefinitions.js";
 import { UniqueConstraintDefinition } from "./UniqueConstraintDefinition.js";
+
 /**
  * Configuration object for a database model.
  */
@@ -12,32 +13,38 @@ export interface ModelDefinition {
      * config applied.
      */
     table?: string;
+
     /**
      * The schema in which the model sits. If not specified, will use the
      * schema specified in the global config; if no schema is specified in
      * the global config, will be set to `public`.
      */
     schema?: string;
+
     /**
      * The model's fields - a map of field name to field
      * definitions. The keys of this map will be used in generated functions
      * and object fields, so must be valid Javascript identifiers.
      */
     fields: Record<string, FieldDefinition>;
+
     /**
      * If the table's primary key contains multiple columns, specify them here.
      * If the primary key is on a single column, you can specify it here or in the column definition.
      */
     primaryKey?: string[] | null;
+
     /**
      * If the table has unique constraints that span multiple columns, you must specify them here.
      * If the unique constraint is on a single column, you can specify it here or in the column definition.
      */
     uniqueConstraints?: UniqueConstraintDefinition[];
+
     /**
      * If the table has foreign keys, you must specify them here. If the foreign key is on a single column,
      * you can specify it here or in the column definition.
      */
     foreignKeys?: ForeignKeyDefinition[];
+
     relations?: RelationDefinitions;
 }

package/{build/definition/ModelDefinitions.d.ts → src/definition/ModelDefinitions.ts}

@@ -1,2 +1,3 @@
 import { ModelDefinition } from "./ModelDefinition.js";
+
 export type ModelDefinitions = Record<string, ModelDefinition>;

package/{build/definition/OperatorDefinitions.d.ts → src/definition/OperatorDefinitions.ts}

@@ -1,4 +1,5 @@
 import { WhereOperatorDefinition } from "./WhereOperator.js";
+
 export type OperatorDefinitions = {
     where: Record<symbol, WhereOperatorDefinition>;
 };

package/{build/definition/PostgresDataTypes.d.ts → src/definition/PostgresDataTypes.ts}

@@ -14,6 +14,7 @@ export interface PostgresDataTypes {
     character_varying: `character varying`;
     character_varying_n: `character varying (${number})`;
     cidr: "cidr";
+    // circle: "circle";
     date: "date";
     daterange: "daterange";
     double_precision: "double precision";
@@ -22,6 +23,7 @@ export interface PostgresDataTypes {
     int4range: "int4range";
     int8range: "int8range";
     integer: "integer";
+    // interval: `interval`;
     json: "json";
     jsonb: "jsonb";
     line: "line";
@@ -35,6 +37,7 @@ export interface PostgresDataTypes {
     oid: "oid";
     path: "path";
     pg_lsn: "pg_lsn";
+    // point: "point";
     polygon: "polygon";
     real: "real";
     regclass: "regclass";

package/{build/definition/RelationDefinition.d.ts → src/definition/RelationDefinition.ts}

@@ -4,6 +4,7 @@ export interface OneToManyRelationDefinition {
     fromField: string | string[];
     toField: string | string[];
 }
+
 export interface ManyToOneRelationDefinition {
     type: "N:1";
     model: string;
@@ -11,6 +12,7 @@ export interface ManyToOneRelationDefinition {
     toField: string | string[];
     optional?: boolean | null;
 }
+
 export interface ManyToManyRelationDefinition {
     type: "N:N";
     model: string;
@@ -20,4 +22,8 @@ export interface ManyToManyRelationDefinition {
         toRelation: string;
     };
 }
-export type RelationDefinition = OneToManyRelationDefinition | ManyToOneRelationDefinition | ManyToManyRelationDefinition;
+
+export type RelationDefinition =
+    | OneToManyRelationDefinition
+    | ManyToOneRelationDefinition
+    | ManyToManyRelationDefinition;

package/{build/definition/RelationDefinitions.d.ts → src/definition/RelationDefinitions.ts}

@@ -1,2 +1,3 @@
 import { RelationDefinition } from "./RelationDefinition.js";
+
 export type RelationDefinitions = Record<string, RelationDefinition>;

package/{build/definition/UniqueConstraintDefinition.d.ts → src/definition/UniqueConstraintDefinition.ts}

@@ -1,4 +1,5 @@
 import { SQLStatement } from "@casekit/sql";
+
 export interface UniqueConstraintDefinition {
     name?: string;
     fields: string[];

package/src/definition/WhereOperator.ts

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

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

@@ -0,0 +1,60 @@
+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();
+});

package/src/helper/DefaultFieldType.ts

@@ -0,0 +1,99 @@
+/**
+ * WARNING!!! The types in this file must be kept in sync
+ * with the zod schemas in packages/orm/src/config/defaultZodSchema.ts.
+ * If you make a change here, make sure to update the
+ * corresponding zod schema.
+ */
+export type DefaultFieldType<DataType extends string> =
+    DataType extends `${infer T extends string}[]`
+        ? DefaultFieldType<T>[]
+        : Uppercase<DataType> extends "BIGINT" | "BIGSERIAL"
+          ? bigint
+          : Uppercase<DataType> extends
+                  | "DOUBLE PRECISION"
+                  | "INTEGER"
+                  | "OID"
+                  | "REAL"
+                  | "SMALLINT"
+                  | "SMALLSERIAL"
+                  | "SERIAL"
+            ? number
+            : Uppercase<DataType> extends
+                    | "BPCHAR"
+                    | "BIT"
+                    | "BOX"
+                    | "CIDR"
+                    | "CHAR"
+                    | "DATERANGE"
+                    | "DECIMAL"
+                    | "INET"
+                    | "INT4RANGE"
+                    | "INT8RANGE"
+                    | "INT2VECTOR"
+                    | "PG_LSN"
+                    | "REGCLASS"
+                    | "REGCONFIG"
+                    | "REGDICTIONARY"
+                    | "REGNAMESPACE"
+                    | "REGOPER"
+                    | "REGOPERATOR"
+                    | "REGPROC"
+                    | "REGPROCEDURE"
+                    | "REGROLE"
+                    | "REGTYPE"
+                    | "TID"
+                    | "XID"
+                    | "NUMRANGE"
+                    | "TSRANGE"
+                    | "TSTZRANGE"
+                    | "LINE"
+                    | "LSEG"
+                    | "MACADDR"
+                    | "MACADDR8"
+                    | "MONEY"
+                    | "PATH"
+                    | "POLYGON"
+                    | "TEXT"
+                    | "TIME"
+                    | "TIMETZ"
+                    | "TSQUERY"
+                    | "TSVECTOR"
+                    | "TXID_SNAPSHOT"
+                    | "XML"
+                    | `BIT${string}`
+                    | `CHARACTER${string}`
+                    | `NUMERIC${string}`
+                    | `TIME ${string}`
+                    | `TIME(${string})`
+                    | `VARCHAR`
+                    | `VARCHAR ${string}`
+              ? string
+              : Uppercase<DataType> extends "BYTEA"
+                ? Buffer
+                : // : Uppercase<DataType> extends "CIRCLE"
+                  //   ? { x: number; y: number; radius: number }
+                  // : Uppercase<DataType> extends "POINT"
+                  //   ? { x: number; y: number }
+                  Uppercase<DataType> extends "JSON" | "JSONB"
+                  ? unknown
+                  : Uppercase<DataType> extends "UUID"
+                    ? string
+                    : Uppercase<DataType> extends "BOOLEAN"
+                      ? boolean
+                      : Uppercase<DataType> extends
+                              | "DATE"
+                              | "TIMESTAMP"
+                              | "TIMESTAMPTZ"
+                              | `TIMESTAMP${string}`
+                        ? Date
+                        : // : Uppercase<DataType> extends "INTERVAL"
+                          //   ? {
+                          //         years?: number;
+                          //         months?: number;
+                          //         days?: number;
+                          //         hours?: number;
+                          //         minutes?: number;
+                          //         seconds?: number;
+                          //         milliseconds?: number;
+                          //     }
+                          unknown;

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

@@ -1,4 +1,8 @@
 import { describe, expectTypeOf, test } from "vitest";
+
+import { ModelDefinition } from "#definition/ModelDefinition.js";
+import { FieldName } from "./FieldName.js";
+
 describe("FieldName", () => {
     test("it evaluates to a string union of the model's column names", () => {
         const model = {
@@ -10,7 +14,10 @@ describe("FieldName", () => {
                 email: { type: "text" },
                 type: { type: "text" },
             },
-        };
-        expectTypeOf().toEqualTypeOf();
+        } as const satisfies ModelDefinition;
+
+        expectTypeOf<FieldName<typeof model>>().toEqualTypeOf<
+            "id" | "name" | "createdAt" | "dateOfBirth" | "email" | "type"
+        >();
     });
 });

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

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

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

@@ -0,0 +1,81 @@
+import { describe, expectTypeOf } from "vitest";
+import { z } from "zod";
+
+import type { ModelDefinition } from "#definition/ModelDefinition.js";
+import type { FieldType } from "./FieldType.js";
+
+const user = {
+    fields: {
+        email: {
+            type: "text",
+            zodSchema: z.email(),
+        },
+        id: {
+            type: "serial",
+        },
+        age: {
+            type: "integer",
+            zodSchema: z.number().min(0).max(150),
+        },
+        tags: {
+            type: "text[]",
+            zodSchema: z.array(z.string()),
+        },
+        status: {
+            type: "text",
+            zodSchema: z.enum(["active", "inactive", "pending"]),
+        },
+        createdAt: {
+            type: "timestamp with time zone",
+        },
+        deletedAt: {
+            type: "timestamp with time zone",
+            zodSchema: z.date().nullable(),
+        },
+        metadata: {
+            type: "jsonb",
+            default: "{}",
+            zodSchema: z.object({
+                foo: z.enum(["a", "b", "c"]),
+                bar: z.array(
+                    z.object({
+                        baz: z.enum(["good", "bad", "indifferent"]),
+                        quux: z.boolean(),
+                    }),
+                ),
+            }),
+        },
+    },
+} as const satisfies ModelDefinition;
+
+type UserModel = typeof user;
+
+describe("FieldType", () => {
+    describe("json field", () => {
+        expectTypeOf<FieldType<UserModel, "metadata">>().toEqualTypeOf<{
+            foo: "a" | "b" | "c";
+            bar: { baz: "good" | "bad" | "indifferent"; quux: boolean }[];
+        }>();
+    });
+
+    describe("fields with Zod schemas", () => {
+        expectTypeOf<FieldType<UserModel, "email">>().toBeString();
+
+        expectTypeOf<FieldType<UserModel, "age">>().toBeNumber();
+
+        expectTypeOf<FieldType<UserModel, "tags">>().toEqualTypeOf<string[]>();
+
+        expectTypeOf<FieldType<UserModel, "status">>().toEqualTypeOf<
+            "active" | "inactive" | "pending"
+        >();
+
+        expectTypeOf<
+            FieldType<UserModel, "deletedAt">
+        >().toEqualTypeOf<Date | null>();
+    });
+
+    describe("fields without Zod schemas (using DefaultFieldType)", () => {
+        expectTypeOf<FieldType<UserModel, "id">>().toBeNumber();
+        expectTypeOf<FieldType<UserModel, "createdAt">>().toEqualTypeOf<Date>();
+    });
+});

package/src/helper/FieldType.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+
+import { ModelDefinition } from "#definition/ModelDefinition.js";
+import { DefaultFieldType } from "./DefaultFieldType.js";
+import { FieldName } from "./FieldName.js";
+
+export type FieldType<
+    Model extends ModelDefinition,
+    C extends FieldName<Model>,
+> = Model["fields"][C]["zodSchema"] extends z.ZodType
+    ?
+          | z.infer<Model["fields"][C]["zodSchema"]>
+          | (Model["fields"][C]["nullable"] extends true ? null : never)
+    :
+          | DefaultFieldType<Model["fields"][C]["type"]>
+          | (Model["fields"][C]["nullable"] extends true ? null : never);

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

@@ -1,4 +1,8 @@
 import { describe, expectTypeOf, test } from "vitest";
+
+import type { ModelDefinition } from "../definition/ModelDefinition.js";
+import type { FieldWithDefault } from "./FieldWithDefault.js";
+
 describe("FieldWithDefault", () => {
     test("extracts just the fields with a default value from the model", () => {
         const user = {
@@ -8,9 +12,13 @@ describe("FieldWithDefault", () => {
                 age: { type: "integer", default: 18 },
                 email: { type: "text", default: null },
             },
-        };
-        expectTypeOf().toEqualTypeOf();
+        } as const satisfies ModelDefinition;
+
+        expectTypeOf<FieldWithDefault<typeof user>>().toEqualTypeOf<
+            "name" | "age"
+        >();
     });
+
     test("returns never if there are no fields with defaults", () => {
         const user = {
             fields: {
@@ -18,9 +26,11 @@ describe("FieldWithDefault", () => {
                 name: { type: "text" },
                 age: { type: "integer" },
             },
-        };
-        expectTypeOf().toEqualTypeOf();
+        } as const satisfies ModelDefinition;
+
+        expectTypeOf<FieldWithDefault<typeof user>>().toEqualTypeOf<never>();
     });
+
     test("excludes fields with null or undefined defaults", () => {
         const user = {
             fields: {
@@ -29,7 +39,8 @@ describe("FieldWithDefault", () => {
                 email: { type: "text", default: null },
                 phone: { type: "text", default: undefined },
             },
-        };
-        expectTypeOf().toEqualTypeOf();
+        } as const satisfies ModelDefinition;
+
+        expectTypeOf<FieldWithDefault<typeof user>>().toEqualTypeOf<"name">();
     });
 });

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

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

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

@@ -1,4 +1,8 @@
 import { describe, expectTypeOf, test } from "vitest";
+
+import { ModelDefinitions } from "../definition/ModelDefinitions.js";
+import { ModelName } from "./ModelName.js";
+
 describe("ModelName", () => {
     test("it evaluates to a string union of the names of the models", () => {
         const models = {
@@ -8,7 +12,10 @@ describe("ModelName", () => {
             comment: { fields: {} },
             mention: { fields: {} },
             color: { fields: {} },
-        };
-        expectTypeOf().toEqualTypeOf();
+        } as const satisfies ModelDefinitions;
+
+        expectTypeOf<ModelName<typeof models>>().toEqualTypeOf<
+            "user" | "post" | "like" | "comment" | "mention" | "color"
+        >();
     });
 });