@casekit/orm2-schema 0.0.1 → 1.0.1

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

@@ -1,19 +1,13 @@
 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 connection?: pg.ConnectionConfig | pg.PoolConfig | pg.PoolOptions | null;
     readonly pool?: boolean;
     readonly logger?: Logger;
     readonly naming?: {

package/build/Config.js

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

package/build/Logger.js

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

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

@@ -1,9 +1,6 @@
 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,
@@ -12,14 +9,10 @@ export interface FieldDefinition {
      * in the config applied.
      */
     column?: string;
-
     /**
      * The postgresql datatype of the column.
      */
-    type:
-        | `${PostgresDataTypes[keyof PostgresDataTypes]}${string}` // the string at the end allows for arrays
-        | `${Uppercase<PostgresDataTypes[keyof PostgresDataTypes]>}${string}`;
-
+    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.
@@ -29,12 +22,10 @@ export interface FieldDefinition {
      * 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,
@@ -51,21 +42,19 @@ 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.
@@ -77,11 +66,9 @@ 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/FieldDefinition.js

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

package/build/definition/ForeignKeyDefinition.js

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

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

@@ -2,7 +2,6 @@ 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.
  */
@@ -13,38 +12,32 @@ 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/ModelDefinition.js

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

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

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

package/build/definition/ModelDefinitions.js

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

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

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

package/build/definition/OperatorDefinitions.js

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

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

@@ -14,7 +14,6 @@ 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";
@@ -23,7 +22,6 @@ export interface PostgresDataTypes {
     int4range: "int4range";
     int8range: "int8range";
     integer: "integer";
-    // interval: `interval`;
     json: "json";
     jsonb: "jsonb";
     line: "line";
@@ -37,7 +35,6 @@ export interface PostgresDataTypes {
     oid: "oid";
     path: "path";
     pg_lsn: "pg_lsn";
-    // point: "point";
     polygon: "polygon";
     real: "real";
     regclass: "regclass";

package/build/definition/PostgresDataTypes.js

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

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

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

package/build/definition/RelationDefinition.js

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

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

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

package/build/definition/RelationDefinitions.js

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

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

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

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/{src/helper/FieldName.ts → build/helper/FieldName.d.ts}

@@ -1,3 +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/{src/helper/FieldName.test-d.ts → build/helper/FieldName.test-d.js}

@@ -1,8 +1,4 @@
 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 = {
@@ -14,10 +10,7 @@ describe("FieldName", () => {
                 email: { type: "text" },
                 type: { type: "text" },
             },
-        } as const satisfies ModelDefinition;
-
-        expectTypeOf<FieldName<typeof model>>().toEqualTypeOf<
-            "id" | "name" | "createdAt" | "dateOfBirth" | "email" | "type"
-        >();
+        };
+        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/{src/helper/FieldWithDefault.ts → build/helper/FieldWithDefault.d.ts}

@@ -1,9 +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;
+    [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/{src/helper/FieldWithDefault.test-d.ts → build/helper/FieldWithDefault.test-d.js}

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

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

@@ -1,6 +1,2 @@
 import { ModelDefinitions } from "#definition/ModelDefinitions.js";
-
-export type ModelName<Models extends ModelDefinitions> = Extract<
-    keyof Models,
-    string
->;
+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/{src/helper/ModelName.test-d.ts → build/helper/ModelName.test-d.js}

@@ -1,8 +1,4 @@
 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 = {
@@ -12,10 +8,7 @@ describe("ModelName", () => {
             comment: { fields: {} },
             mention: { fields: {} },
             color: { fields: {} },
-        } as const satisfies ModelDefinitions;
-
-        expectTypeOf<ModelName<typeof models>>().toEqualTypeOf<
-            "user" | "post" | "like" | "comment" | "mention" | "color"
-        >();
+        };
+        expectTypeOf().toEqualTypeOf();
     });
 });

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

@@ -1,8 +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/{src/helper/ModelType.test-d.ts → build/helper/ModelType.test-d.js}

@@ -1,9 +1,5 @@
 import { describe, expectTypeOf } from "vitest";
 import { z } from "zod";
-
-import type { ModelDefinition } from "#definition/ModelDefinition.js";
-import { ModelType } from "./ModelType.js";
-
 const user = {
     fields: {
         email: {
@@ -33,20 +29,9 @@ const user = {
             zodSchema: z.date().nullable(),
         },
     },
-} as const satisfies ModelDefinition;
-
+};
 describe("ModelType", () => {
     describe("Evaluate to a type containing all the fields of the", () => {
-        expectTypeOf<ModelType<typeof user>>().toEqualTypeOf<
-            Readonly<{
-                email: string;
-                id: number;
-                age: number;
-                tags: string[];
-                status: "active" | "inactive" | "pending";
-                createdAt: Date;
-                deletedAt: Date | null;
-            }>
-        >();
+        expectTypeOf().toEqualTypeOf();
     });
 });

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

@@ -1,7 +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;
+    [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 {};