@casekit/orm-schema 0.0.1-release-candidate

package/build/Config.d.ts

@@ -0,0 +1,17 @@
+import pg from "pg";
+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 pool?: boolean;
+    readonly logger?: Logger;
+    readonly naming?: {
+        readonly column?: (name: string) => string;
+        readonly table?: (name: string) => string;
+    };
+}

package/build/Config.js

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

package/build/Logger.d.ts

@@ -0,0 +1,6 @@
+export interface Logger {
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}

package/build/Logger.js

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

package/build/definition/FieldDefinition.d.ts

@@ -0,0 +1,74 @@
+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,
+     * it will be inferred based on the model's field name,
+     * with any column naming function (e.g. `snakeCase`) specified
+     * in the config applied.
+     */
+    column?: string;
+    /**
+     * The postgresql datatype of the column.
+     */
+    type: `${PostgresDataTypes[keyof PostgresDataTypes]}${string}` | `${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.
+     * If not specified, an attempt will be made to infer a basic schema
+     * based on the postgresql data type of the column. Specifying it
+     * allows to you configure more sophisticated parsing, validation,
+     * and transformations.
+     */
+    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,
+     * you can use the `sql` tagged template literal. Examples include:
+     *
+     * default: 3,
+     *
+     * or
+     *
+     * default: "foo",
+     *
+     * or
+     *
+     * 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;
+    };
+    /**
+     * 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;
+        model: string;
+        field: string;
+        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/FieldDefinition.js

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

package/build/definition/ForeignKeyDefinition.d.ts

@@ -0,0 +1,10 @@
+export interface ForeignKeyDefinition {
+    name?: string;
+    fields: Array<string>;
+    references: {
+        model: string;
+        fields: string[];
+    };
+    onUpdate?: "RESTRICT" | "CASCADE" | "SET NULL" | "SET DEFAULT" | null;
+    onDelete?: "RESTRICT" | "CASCADE" | "SET NULL" | "SET DEFAULT" | null;
+}

package/build/definition/ForeignKeyDefinition.js

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

package/build/definition/ModelDefinition.d.ts

@@ -0,0 +1,43 @@
+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.
+ */
+export interface ModelDefinition {
+    /**
+     * The name of the model's table. If not specified, the table name will be
+     * derived from the model name, with any transform function specified in
+     * 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/ModelDefinition.js

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

package/build/definition/ModelDefinitions.d.ts

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

package/build/definition/ModelDefinitions.js

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

package/build/definition/OperatorDefinitions.d.ts

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

package/build/definition/OperatorDefinitions.js

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

package/build/definition/PostgresDataTypes.d.ts

@@ -0,0 +1,78 @@
+export interface PostgresDataTypes {
+    bigint: "bigint";
+    bigserial: "bigserial";
+    bit: `bit`;
+    bit_n: `bit (${number})`;
+    bit_varying: `bit varying`;
+    bit_varying_n: `bit varying (${number})`;
+    boolean: "boolean";
+    box: "box";
+    bytea: "bytea";
+    char: `char`;
+    character: `character`;
+    character_n: `character (${number})`;
+    character_varying: `character varying`;
+    character_varying_n: `character varying (${number})`;
+    cidr: "cidr";
+    date: "date";
+    daterange: "daterange";
+    double_precision: "double precision";
+    inet: "inet";
+    int2vector: "int2vector";
+    int4range: "int4range";
+    int8range: "int8range";
+    integer: "integer";
+    json: "json";
+    jsonb: "jsonb";
+    line: "line";
+    lseg: "lseg";
+    macaddr: "macaddr";
+    macaddr8: "macaddr8";
+    money: "money";
+    numeric: "numeric";
+    numeric_p_s: `numeric (${number}, ${number})`;
+    numrange: "numrange";
+    oid: "oid";
+    path: "path";
+    pg_lsn: "pg_lsn";
+    polygon: "polygon";
+    real: "real";
+    regclass: "regclass";
+    regconfig: "regconfig";
+    regdictionary: "regdictionary";
+    regnamespace: "regnamespace";
+    regoper: "regoper";
+    regoperator: "regoperator";
+    regproc: "regproc";
+    regprocedure: "regprocedure";
+    regrole: "regrole";
+    regtype: "regtype";
+    smallint: "smallint";
+    smallserial: "smallserial";
+    serial: "serial";
+    text: "text";
+    tid: "tid";
+    time: "time";
+    time_p: `time(${number})` | `time (${number})`;
+    time_with_timezone: "time with time zone";
+    time_without_timezone: "time without time zone";
+    time_p_with_timezone: `time (${number}) with time zone`;
+    time_p_without_timezone: `time (${number}) without time zone`;
+    timetz: "timetz";
+    timestamp: "timestamp";
+    timestamp_p: `timestamp (${number})`;
+    timestamp_with_timezone: "timestamp with time zone";
+    timestamp_without_timezone: "timestamp without time zone";
+    timestamp_p_with_timezone: `timestamp (${number}) with time zone`;
+    timestamp_p_without_timezone: `timestamp (${number}) without time zone`;
+    timestamptz: "timestamptz";
+    tsquery: "tsquery";
+    tsrange: "tsrange";
+    tstzrange: "tstzrange";
+    tsvector: "tsvector";
+    txid_snapshot: "txid_snapshot";
+    uuid: "uuid";
+    varchar: "varchar";
+    xid: "xid";
+    xml: "xml";
+}

package/build/definition/PostgresDataTypes.js

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

package/build/definition/RelationDefinition.d.ts

@@ -0,0 +1,23 @@
+export interface OneToManyRelationDefinition {
+    type: "1:N";
+    model: string;
+    fromField: string | string[];
+    toField: string | string[];
+}
+export interface ManyToOneRelationDefinition {
+    type: "N:1";
+    model: string;
+    fromField: string | string[];
+    toField: string | string[];
+    optional?: boolean | null;
+}
+export interface ManyToManyRelationDefinition {
+    type: "N:N";
+    model: string;
+    through: {
+        model: string;
+        fromRelation: string;
+        toRelation: string;
+    };
+}
+export type RelationDefinition = OneToManyRelationDefinition | ManyToOneRelationDefinition | ManyToManyRelationDefinition;

package/build/definition/RelationDefinition.js

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

package/build/definition/RelationDefinitions.d.ts

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

package/build/definition/RelationDefinitions.js

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

package/build/definition/UniqueConstraintDefinition.d.ts

@@ -0,0 +1,7 @@
+import { SQLStatement } from "@casekit/sql";
+export interface UniqueConstraintDefinition {
+    name?: string;
+    fields: string[];
+    where?: SQLStatement | null;
+    nullsNotDistinct?: boolean;
+}

package/build/definition/UniqueConstraintDefinition.js

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

package/build/definition/WhereOperator.d.ts

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

package/build/definition/WhereOperator.js

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

package/build/helper/DefaultFieldType.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 "JSON" | "JSONB" ? unknown : Uppercase<DataType> extends "UUID" ? string : Uppercase<DataType> extends "BOOLEAN" ? boolean : Uppercase<DataType> extends "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | `TIMESTAMP${string}` ? Date : unknown;

package/build/helper/DefaultFieldType.js

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

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

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

package/build/helper/DefaultFieldType.test-d.js

@@ -0,0 +1,57 @@
+import { expectTypeOf, test } from "vitest";
+test("DefaultFieldType", () => {
+    expectTypeOf().toBeBigInt();
+    expectTypeOf().toBeNumber();
+    expectTypeOf().toBeNumber();
+    expectTypeOf().toBeNumber();
+    expectTypeOf().toBeNumber();
+    expectTypeOf().toBeNumber();
+    expectTypeOf().toBeNumber();
+    expectTypeOf().toBeNumber();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+    expectTypeOf().toEqualTypeOf();
+    // expectTypeOf<DefaultFieldType<"circle">>().toEqualTypeOf<{
+    //     x: number;
+    //     y: number;
+    //     radius: number;
+    // }>();
+    // expectTypeOf<DefaultFieldType<"point">>().toEqualTypeOf<{
+    //     x: number;
+    //     y: number;
+    // }>();
+    expectTypeOf().toBeUnknown();
+    expectTypeOf().toBeUnknown();
+    expectTypeOf().toBeBoolean();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
+    // expectTypeOf<DefaultFieldType<"interval">>().toEqualTypeOf<{
+    //     years?: number;
+    //     months?: number;
+    //     days?: number;
+    //     hours?: number;
+    //     minutes?: number;
+    //     seconds?: number;
+    //     milliseconds?: number;
+    // }>();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+    expectTypeOf().toBeString();
+});

package/build/helper/FieldName.d.ts

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

package/build/helper/FieldName.js

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

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

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

package/build/helper/FieldName.test-d.js

@@ -0,0 +1,16 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("FieldName", () => {
+    test("it evaluates to a string union of the model's column names", () => {
+        const model = {
+            fields: {
+                id: { type: "serial" },
+                name: { type: "text" },
+                createdAt: { type: "timestamp" },
+                dateOfBirth: { type: "date" },
+                email: { type: "text" },
+                type: { type: "text" },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/build/helper/FieldType.d.ts

@@ -0,0 +1,5 @@
+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/FieldType.js

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

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

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

package/build/helper/FieldType.test-d.js

@@ -0,0 +1,59 @@
+import { describe, expectTypeOf } from "vitest";
+import { z } from "zod";
+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(),
+                })),
+            }),
+        },
+    },
+};
+describe("FieldType", () => {
+    describe("json field", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    describe("fields with Zod schemas", () => {
+        expectTypeOf().toBeString();
+        expectTypeOf().toBeNumber();
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+    });
+    describe("fields without Zod schemas (using DefaultFieldType)", () => {
+        expectTypeOf().toBeNumber();
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/build/helper/FieldWithDefault.d.ts

@@ -0,0 +1,4 @@
+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;
+}[keyof Model["fields"]];

package/build/helper/FieldWithDefault.js

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

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

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

package/build/helper/FieldWithDefault.test-d.js

@@ -0,0 +1,35 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("FieldWithDefault", () => {
+    test("extracts just the fields with a default value from the model", () => {
+        const user = {
+            fields: {
+                id: { type: "serial" },
+                name: { type: "text", default: "Anonymous" },
+                age: { type: "integer", default: 18 },
+                email: { type: "text", default: null },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("returns never if there are no fields with defaults", () => {
+        const user = {
+            fields: {
+                id: { type: "serial" },
+                name: { type: "text" },
+                age: { type: "integer" },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("excludes fields with null or undefined defaults", () => {
+        const user = {
+            fields: {
+                id: { type: "serial" },
+                name: { type: "text", default: "Anonymous" },
+                email: { type: "text", default: null },
+                phone: { type: "text", default: undefined },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/build/helper/ModelName.d.ts

@@ -0,0 +1,2 @@
+import { ModelDefinitions } from "#definition/ModelDefinitions.js";
+export type ModelName<Models extends ModelDefinitions> = Extract<keyof Models, string>;

package/build/helper/ModelName.js

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

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

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

package/build/helper/ModelName.test-d.js

@@ -0,0 +1,14 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("ModelName", () => {
+    test("it evaluates to a string union of the names of the models", () => {
+        const models = {
+            user: { fields: {} },
+            post: { fields: {} },
+            like: { fields: {} },
+            comment: { fields: {} },
+            mention: { fields: {} },
+            color: { fields: {} },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/build/helper/ModelType.d.ts

@@ -0,0 +1,6 @@
+import { Simplify } from "@casekit/toolbox";
+import { ModelDefinition } from "#definition/ModelDefinition.js";
+import { FieldType } from "./FieldType.js";
+export type ModelType<Model extends ModelDefinition> = Simplify<{
+    [C in keyof Model["fields"]]: FieldType<Model, C>;
+}>;

package/build/helper/ModelType.js

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

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

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

package/build/helper/ModelType.test-d.js

@@ -0,0 +1,37 @@
+import { describe, expectTypeOf } from "vitest";
+import { z } from "zod";
+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(),
+        },
+    },
+};
+describe("ModelType", () => {
+    describe("Evaluate to a type containing all the fields of the", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/build/helper/NullableField.d.ts

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

package/build/helper/NullableField.js

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

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

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

package/build/helper/NullableField.test-d.js

@@ -0,0 +1,34 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("NullableField", () => {
+    test("extracts just the nullable fields from the model", () => {
+        const user = {
+            fields: {
+                id: { type: "serial", nullable: false },
+                name: { type: "text", nullable: true },
+                email: { type: "text", nullable: true },
+                age: { type: "integer", nullable: false },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("returns never if there are no nullable fields", () => {
+        const user = {
+            fields: {
+                id: { type: "serial", nullable: false },
+                name: { type: "text", nullable: false },
+                age: { type: "integer", nullable: false },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("treats fields without nullable property as non-nullable", () => {
+        const user = {
+            fields: {
+                id: { type: "serial" },
+                name: { type: "text", nullable: true },
+                age: { type: "integer" },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/build/helper/OptionalField.d.ts

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

package/build/helper/OptionalField.js

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

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

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

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

@@ -0,0 +1,39 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("OptionalField", () => {
+    test("extracts fields that are optional for insert", () => {
+        const user = {
+            fields: {
+                id: { type: "serial", nullable: false },
+                name: { type: "text", nullable: false },
+                email: { type: "text", nullable: false },
+                age: { type: "integer", nullable: false, default: 18 },
+                role: { type: "text", nullable: false, provided: true },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("returns all fields if none are required", () => {
+        const user = {
+            fields: {
+                id: { type: "serial" },
+                name: { type: "text", nullable: true },
+                age: { type: "integer", default: 18 },
+                role: { type: "text", provided: true },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("includes fields with defaults, serial fields, nullable fields and provided fields", () => {
+        const user = {
+            fields: {
+                id: { type: "serial" },
+                name: { type: "text", nullable: false },
+                email: { type: "text", nullable: true },
+                age: { type: "integer", default: 18 },
+                role: { type: "text", provided: true },
+                score: { type: "integer", nullable: false },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/build/helper/ProvidedField.d.ts

@@ -0,0 +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;
+}[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/build/helper/ProvidedField.test-d.js

@@ -0,0 +1,34 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("ProvidedField", () => {
+    test("extracts just the provided fields from the model", () => {
+        const user = {
+            fields: {
+                id: { type: "serial", provided: false },
+                createdAt: { type: "timestamp", provided: true },
+                updatedAt: { type: "timestamp", provided: true },
+                name: { type: "text", provided: false },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("returns never if there are no provided fields", () => {
+        const user = {
+            fields: {
+                id: { type: "serial", provided: false },
+                name: { type: "text", provided: false },
+                age: { type: "integer", provided: false },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("treats fields without provided property as non-provided", () => {
+        const user = {
+            fields: {
+                id: { type: "serial" },
+                createdAt: { type: "timestamp", provided: true },
+                name: { type: "text" },
+            },
+        };
+        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/build/helper/RelationModel.test-d.js

@@ -0,0 +1,60 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("RelationModel", () => {
+    const models = {
+        user: {
+            fields: {},
+            relations: {
+                posts: {
+                    type: "1:N",
+                    model: "post",
+                    fromField: "id",
+                    toField: "authorId",
+                },
+                likedPosts: {
+                    type: "N:N",
+                    model: "post",
+                    through: {
+                        model: "like",
+                        fromRelation: "user",
+                        toRelation: "post",
+                    },
+                },
+            },
+        },
+        post: {
+            fields: {},
+            relations: {
+                author: {
+                    type: "N:1",
+                    model: "user",
+                    fromField: "authorId",
+                    toField: "id",
+                },
+                likes: {
+                    type: "1:N",
+                    model: "like",
+                    fromField: "id",
+                    toField: "postId",
+                },
+            },
+        },
+        like: { fields: {} },
+    };
+    test("looks up the correct relation model in the schema for N:1 relations", () => {
+        expectTypeOf().toExtend();
+    });
+    test("looks up the correct relation model in the schema for 1:N relations", () => {
+        expectTypeOf().toExtend();
+    });
+    test("looks up the correct relation model in the schema for N:N relations", () => {
+        expectTypeOf().toExtend();
+    });
+    describe("errors", () => {
+        test("looking up a non-existing relation causes an error", () => {
+            expectTypeOf().not.toExtend();
+        });
+        test("looking up a relation for a model that doesn't exist causes an error", () => {
+            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/build/helper/RelationName.test-d.js

@@ -0,0 +1,44 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("RelationName", () => {
+    test("it evaluates to a string union of the names of the model's relations", () => {
+        const user = {
+            fields: { id: { type: "serial" } },
+            relations: {
+                posts: {
+                    type: "1:N",
+                    model: "post",
+                    fromField: "id",
+                    toField: "authorId",
+                },
+                friends: {
+                    type: "N:N",
+                    model: "user",
+                    through: {
+                        model: "friendship",
+                        fromRelation: "user",
+                        toRelation: "friend",
+                    },
+                },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+        const post = {
+            fields: { id: { type: "serial" } },
+            relations: {
+                author: {
+                    type: "N:1",
+                    model: "user",
+                    fromField: "authorId",
+                    toField: "id",
+                },
+                likes: {
+                    type: "1:N",
+                    model: "like",
+                    fromField: "id",
+                    toField: "postId",
+                },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/build/helper/RequiredField.d.ts

@@ -0,0 +1,7 @@
+import { ModelDefinition } from "#definition/ModelDefinition.js";
+import { FieldName } from "./FieldName.js";
+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>>;

package/build/helper/RequiredField.js

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

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

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

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

@@ -0,0 +1,39 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("RequiredField", () => {
+    test("extracts fields that are required for insert", () => {
+        const user = {
+            fields: {
+                id: { type: "serial", nullable: false },
+                name: { type: "text", nullable: false },
+                email: { type: "text", nullable: false },
+                age: { type: "integer", nullable: false, default: 18 },
+                role: { type: "text", nullable: false, provided: true },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("returns never if all fields are optional", () => {
+        const user = {
+            fields: {
+                id: { type: "serial" },
+                name: { type: "text", nullable: true },
+                age: { type: "integer", default: 18 },
+                role: { type: "text", provided: true },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("excludes fields with defaults, serial fields, nullable fields and provided fields", () => {
+        const user = {
+            fields: {
+                id: { type: "serial" },
+                name: { type: "text", nullable: false },
+                email: { type: "text", nullable: true },
+                age: { type: "integer", default: 18 },
+                role: { type: "text", provided: true },
+                score: { type: "integer", nullable: false },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/build/helper/SerialField.d.ts

@@ -0,0 +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;
+}[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/build/helper/SerialField.test-d.js

@@ -0,0 +1,46 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("SerialField", () => {
+    test("extracts just the fields with a SERIAL datatype from the model", () => {
+        const user = {
+            fields: {
+                id: { type: "serial" },
+                smallId: { type: "smallserial" },
+                bigId: { type: "bigserial" },
+                name: { type: "text" },
+                age: { type: "integer" },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("works for both lower and uppercase field types", () => {
+        const user = {
+            fields: {
+                id: { type: "SERIAL" },
+                smallId: { type: "SMALLSERIAL" },
+                bigId: { type: "BIGSERIAL" },
+                name: { type: "TEXT" },
+                age: { type: "INTEGER" },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("returns never if there are no SERIAL fields", () => {
+        const user = {
+            fields: {
+                name: { type: "text" },
+                age: { type: "integer" },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("does not include fields with a type that end with serial but isn't a serial type", () => {
+        const user = {
+            fields: {
+                id: { type: "serial" },
+                name: { type: "text" },
+                age: { type: "integer" },
+            },
+        };
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/build/index.d.ts

@@ -0,0 +1,25 @@
+export type { FieldDefinition } from "./definition/FieldDefinition.js";
+export type { ForeignKeyDefinition } from "./definition/ForeignKeyDefinition.js";
+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 { 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";
+export type { FieldWithDefault } from "./helper/FieldWithDefault.js";
+export type { ModelName } from "./helper/ModelName.js";
+export type { ModelType } from "./helper/ModelType.js";
+export type { NullableField } from "./helper/NullableField.js";
+export type { OptionalField } from "./helper/OptionalField.js";
+export type { ProvidedField } from "./helper/ProvidedField.js";
+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

@@ -0,0 +1,50 @@
+{
+  "name": "@casekit/orm-schema",
+  "description": "",
+  "version": "0.0.1-release-candidate",
+  "author": "",
+  "dependencies": {
+    "@casekit/sql": "0.0.1-release-candidate",
+    "@casekit/toolbox": "0.0.1-release-candidate"
+  },
+  "devDependencies": {
+    "@trivago/prettier-plugin-sort-imports": "^5.2.2",
+    "@types/node": "^24.0.3",
+    "@types/pg": "^8.15.4",
+    "@types/uuid": "^10.0.0",
+    "prettier": "^3.5.3",
+    "ts-essentials": "^10.1.1",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.34.1",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.2.4",
+    "@casekit/tsconfig": "0.0.1-release-candidate",
+    "@casekit/prettier-config": "0.0.1-release-candidate"
+  },
+  "exports": {
+    ".": "./build/index.js"
+  },
+  "files": [
+    "/build"
+  ],
+  "imports": {
+    "#*": "./build/*"
+  },
+  "keywords": [],
+  "license": "ISC",
+  "peerDependencies": {
+    "pg": "^8.13.1",
+    "zod": "^4.0.17"
+  },
+  "prettier": "@casekit/prettier-config",
+  "type": "module",
+  "scripts": {
+    "build": "rm -rf ./build && tsc",
+    "format:check": "prettier --check .",
+    "format": "prettier --write .",
+    "lint": "eslint src --max-warnings 0",
+    "test": "vitest --run --typecheck",
+    "test:watch": "vitest --typecheck",
+    "typecheck": "tsc --noEmit"
+  }
+}