@casekit/orm2-fixtures 0.0.1 → 1.0.1

package/build/index.d.ts

@@ -0,0 +1,528 @@
+import { snakeCase } from "es-toolkit";
+import { models } from "./models/index.js";
+export { models } from "./models/index.js";
+export type Models = typeof models;
+export type Operators = {
+    where: Record<symbol, never>;
+};
+export declare const config: {
+    schema: string;
+    models: {
+        audit: {
+            readonly fields: {
+                readonly id: {
+                    readonly type: "serial";
+                    readonly primaryKey: true;
+                };
+                readonly change: {
+                    readonly type: "text";
+                    readonly provided: true;
+                };
+                readonly userId: {
+                    readonly type: "integer";
+                };
+            };
+        };
+        counter: {
+            readonly fields: {
+                readonly counter: {
+                    readonly type: "serial";
+                    readonly primaryKey: true;
+                };
+            };
+        };
+        user: {
+            readonly fields: {
+                readonly id: {
+                    readonly type: "serial";
+                    readonly primaryKey: true;
+                };
+                readonly name: {
+                    readonly type: "text";
+                };
+                readonly email: {
+                    readonly type: "text";
+                    readonly zodSchema: import("zod").ZodEmail;
+                };
+                readonly role: {
+                    readonly type: "text";
+                    readonly zodSchema: import("zod").ZodEnum<{
+                        user: "user";
+                        admin: "admin";
+                    }>;
+                };
+                readonly preferences: {
+                    readonly type: "jsonb";
+                    readonly default: "{}";
+                };
+                readonly createdAt: {
+                    readonly type: "timestamp";
+                    readonly default: import("@casekit/sql").SQLStatement<import("pg").QueryResultRow>;
+                };
+                readonly deletedAt: {
+                    readonly type: "timestamp";
+                    readonly nullable: true;
+                };
+            };
+            readonly uniqueConstraints: [{
+                readonly fields: ["email", "deletedAt"];
+                readonly nullsNotDistinct: true;
+            }];
+            readonly relations: {
+                readonly posts: {
+                    readonly type: "1:N";
+                    readonly model: "post";
+                    readonly fromField: "id";
+                    readonly toField: "authorId";
+                };
+                readonly friends: {
+                    readonly type: "N:N";
+                    readonly model: "user";
+                    readonly through: {
+                        readonly model: "friendship";
+                        readonly fromRelation: "user";
+                        readonly toRelation: "friend";
+                    };
+                };
+                readonly friendships: {
+                    readonly type: "1:N";
+                    readonly model: "friendship";
+                    readonly fromField: "id";
+                    readonly toField: "userId";
+                };
+            };
+        };
+        post: {
+            readonly fields: {
+                readonly id: {
+                    readonly type: "serial";
+                    readonly primaryKey: true;
+                };
+                readonly title: {
+                    readonly type: "text";
+                };
+                readonly content: {
+                    readonly type: "text";
+                };
+                readonly tags: {
+                    readonly type: "text[]";
+                    readonly default: "{}";
+                };
+                readonly authorId: {
+                    readonly type: "integer";
+                    readonly references: {
+                        readonly model: "user";
+                        readonly field: "id";
+                    };
+                };
+                readonly backgroundColorValue: {
+                    readonly type: "text";
+                    readonly nullable: true;
+                    readonly references: {
+                        readonly model: "color";
+                        readonly field: "hex";
+                        readonly onDelete: "SET NULL";
+                    };
+                };
+                readonly metadata: {
+                    readonly type: "jsonb";
+                    readonly default: "{}";
+                    readonly zodSchema: import("zod").ZodObject<{
+                        foo: import("zod").ZodEnum<{
+                            b: "b";
+                            a: "a";
+                            c: "c";
+                        }>;
+                        bar: import("zod").ZodArray<import("zod").ZodObject<{
+                            baz: import("zod").ZodEnum<{
+                                good: "good";
+                                bad: "bad";
+                                indifferent: "indifferent";
+                            }>;
+                            quux: import("zod").ZodBoolean;
+                        }, import("zod/v4/core").$strip>>;
+                    }, import("zod/v4/core").$strip>;
+                };
+                readonly createdAt: {
+                    readonly type: "timestamp";
+                    readonly default: import("@casekit/sql").SQLStatement<import("pg").QueryResultRow>;
+                };
+                readonly publishedAt: {
+                    readonly type: "timestamp";
+                    readonly nullable: true;
+                };
+                readonly deletedAt: {
+                    readonly type: "timestamp";
+                    readonly nullable: true;
+                };
+            };
+            readonly relations: {
+                readonly author: {
+                    readonly type: "N:1";
+                    readonly model: "user";
+                    readonly fromField: "authorId";
+                    readonly toField: "id";
+                };
+                readonly backgroundColor: {
+                    readonly type: "N:1";
+                    readonly model: "color";
+                    readonly fromField: "backgroundColorValue";
+                    readonly toField: "hex";
+                    readonly optional: true;
+                };
+                readonly likes: {
+                    readonly type: "1:N";
+                    readonly model: "like";
+                    readonly fromField: "id";
+                    readonly toField: "postId";
+                };
+            };
+        };
+        like: {
+            readonly fields: {
+                readonly id: {
+                    readonly type: "serial";
+                    readonly primaryKey: true;
+                };
+                readonly userId: {
+                    readonly type: "integer";
+                    readonly references: {
+                        readonly model: "user";
+                        readonly field: "id";
+                        readonly onDelete: "CASCADE";
+                    };
+                };
+                readonly postId: {
+                    readonly type: "integer";
+                    readonly references: {
+                        readonly model: "post";
+                        readonly field: "id";
+                        readonly onDelete: "CASCADE";
+                    };
+                };
+                readonly createdAt: {
+                    readonly type: "timestamp";
+                    readonly default: import("@casekit/sql").SQLStatement<import("pg").QueryResultRow>;
+                };
+                readonly deletedAt: {
+                    readonly type: "timestamp";
+                    readonly nullable: true;
+                };
+            };
+            readonly uniqueConstraints: [{
+                readonly fields: ["userId", "postId"];
+                readonly where: import("@casekit/sql").SQLStatement<import("pg").QueryResultRow>;
+            }];
+            readonly relations: {
+                readonly user: {
+                    readonly type: "N:1";
+                    readonly model: "user";
+                    readonly fromField: "userId";
+                    readonly toField: "id";
+                };
+                readonly post: {
+                    readonly type: "N:1";
+                    readonly model: "post";
+                    readonly fromField: "postId";
+                    readonly toField: "id";
+                };
+            };
+        };
+        color: {
+            readonly fields: {
+                readonly hex: {
+                    readonly type: "text";
+                    readonly primaryKey: true;
+                };
+                readonly name: {
+                    readonly type: "text";
+                };
+            };
+        };
+        friendship: {
+            readonly fields: {
+                readonly userId: {
+                    readonly type: "integer";
+                };
+                readonly friendId: {
+                    readonly type: "integer";
+                };
+            };
+            readonly primaryKey: ["userId", "friendId"];
+            readonly relations: {
+                readonly user: {
+                    readonly type: "N:1";
+                    readonly model: "user";
+                    readonly fromField: "userId";
+                    readonly toField: "id";
+                };
+                readonly friend: {
+                    readonly type: "N:1";
+                    readonly model: "user";
+                    readonly fromField: "friendId";
+                    readonly toField: "id";
+                };
+                readonly stats: {
+                    readonly type: "N:1";
+                    readonly model: "friendshipStats";
+                    readonly fromField: ["userId", "friendId"];
+                    readonly toField: ["userId", "friendId"];
+                    readonly optional: true;
+                };
+            };
+        };
+        friendshipStats: {
+            readonly fields: {
+                readonly id: {
+                    readonly type: "serial";
+                    readonly primaryKey: true;
+                };
+                readonly userId: {
+                    readonly type: "integer";
+                };
+                readonly friendId: {
+                    readonly type: "integer";
+                };
+                readonly messagesSent: {
+                    readonly type: "integer";
+                    readonly default: 0;
+                };
+                readonly likesGiven: {
+                    readonly type: "integer";
+                    readonly default: 0;
+                };
+            };
+            readonly foreignKeys: [{
+                readonly fields: ["userId", "friendId"];
+                readonly references: {
+                    readonly model: "friendship";
+                    readonly fields: ["userId", "friendId"];
+                };
+                readonly onDelete: "CASCADE";
+            }];
+            readonly relations: {
+                readonly friendship: {
+                    readonly type: "N:1";
+                    readonly model: "friendship";
+                    readonly fromField: ["userId", "friendId"];
+                    readonly toField: ["userId", "friendId"];
+                };
+            };
+        };
+        kitchenSink: {
+            readonly fields: {
+                readonly id: {
+                    readonly type: "serial";
+                    readonly primaryKey: true;
+                };
+                readonly charField: {
+                    readonly type: "char";
+                };
+                readonly characterField: {
+                    readonly type: "character";
+                };
+                readonly characterNField: {
+                    readonly type: "character(24)";
+                };
+                readonly varcharField: {
+                    readonly type: "character varying";
+                };
+                readonly varcharNField: {
+                    readonly type: "character varying(24)";
+                };
+                readonly textField: {
+                    readonly type: "text";
+                };
+                readonly bitField: {
+                    readonly type: "bit";
+                };
+                readonly bitNField: {
+                    readonly type: "bit(3)";
+                };
+                readonly bitVaryingField: {
+                    readonly type: "bit varying";
+                };
+                readonly bitVaryingNField: {
+                    readonly type: "bit varying(3)";
+                };
+                readonly numericField: {
+                    readonly type: "numeric";
+                };
+                readonly numericPrecisionField: {
+                    readonly type: "numeric(5,2)";
+                };
+                readonly integerField: {
+                    readonly type: "integer";
+                };
+                readonly bigintField: {
+                    readonly type: "bigint";
+                };
+                readonly smallintField: {
+                    readonly type: "smallint";
+                };
+                readonly serialField: {
+                    readonly type: "serial";
+                };
+                readonly bigserialField: {
+                    readonly type: "bigserial";
+                };
+                readonly smallserialField: {
+                    readonly type: "smallserial";
+                };
+                readonly doublePrecisionField: {
+                    readonly type: "double precision";
+                };
+                readonly realField: {
+                    readonly type: "real";
+                };
+                readonly moneyField: {
+                    readonly type: "money";
+                };
+                readonly booleanField: {
+                    readonly type: "boolean";
+                };
+                readonly uuidField: {
+                    readonly type: "uuid";
+                };
+                readonly dateField: {
+                    readonly type: "date";
+                };
+                readonly timeField: {
+                    readonly type: "time";
+                };
+                readonly timeWithPrecisionField: {
+                    readonly type: "time(3)";
+                };
+                readonly timetzField: {
+                    readonly type: "timetz";
+                };
+                readonly timeWithTzField: {
+                    readonly type: "time with time zone";
+                };
+                readonly timestampField: {
+                    readonly type: "timestamp";
+                };
+                readonly timestampWithPrecisionField: {
+                    readonly type: "timestamp(6)";
+                };
+                readonly timestamptzField: {
+                    readonly type: "timestamptz";
+                };
+                readonly timestampWithTzField: {
+                    readonly type: "timestamp with time zone";
+                };
+                readonly jsonField: {
+                    readonly type: "json";
+                };
+                readonly jsonbField: {
+                    readonly type: "jsonb";
+                };
+                readonly lineField: {
+                    readonly type: "line";
+                };
+                readonly lsegField: {
+                    readonly type: "lseg";
+                };
+                readonly boxField: {
+                    readonly type: "box";
+                };
+                readonly polygonField: {
+                    readonly type: "polygon";
+                };
+                readonly cidrField: {
+                    readonly type: "cidr";
+                };
+                readonly inetField: {
+                    readonly type: "inet";
+                };
+                readonly macaddrField: {
+                    readonly type: "macaddr";
+                };
+                readonly macaddr8Field: {
+                    readonly type: "macaddr8";
+                };
+                readonly byteaField: {
+                    readonly type: "bytea";
+                };
+                readonly xmlField: {
+                    readonly type: "xml";
+                };
+                readonly pathField: {
+                    readonly type: "path";
+                };
+                readonly tsqueryField: {
+                    readonly type: "tsquery";
+                };
+                readonly tsvectorField: {
+                    readonly type: "tsvector";
+                };
+                readonly int4rangeField: {
+                    readonly type: "int4range";
+                };
+                readonly int8rangeField: {
+                    readonly type: "int8range";
+                };
+                readonly numrangeField: {
+                    readonly type: "numrange";
+                };
+                readonly tsrangeField: {
+                    readonly type: "tsrange";
+                };
+                readonly tstzrangeField: {
+                    readonly type: "tstzrange";
+                };
+                readonly daterangeField: {
+                    readonly type: "daterange";
+                };
+                readonly int2vectorField: {
+                    readonly type: "int2vector";
+                };
+                readonly oidField: {
+                    readonly type: "oid";
+                };
+                readonly pglsnField: {
+                    readonly type: "pg_lsn";
+                };
+                readonly regclassField: {
+                    readonly type: "regclass";
+                };
+                readonly regnamespaceField: {
+                    readonly type: "regnamespace";
+                };
+                readonly regprocField: {
+                    readonly type: "regproc";
+                };
+                readonly regprocedureField: {
+                    readonly type: "regprocedure";
+                };
+                readonly regroleField: {
+                    readonly type: "regrole";
+                };
+                readonly regtypeField: {
+                    readonly type: "regtype";
+                };
+                readonly tidField: {
+                    readonly type: "tid";
+                };
+                readonly xidField: {
+                    readonly type: "xid";
+                };
+                readonly txidSnapshotField: {
+                    readonly type: "txid_snapshot";
+                };
+                readonly arrayField: {
+                    readonly type: "text[]";
+                };
+                readonly multiArrayField: {
+                    readonly type: "text[][][]";
+                };
+            };
+        };
+    };
+    naming: {
+        table: typeof snakeCase;
+        column: typeof snakeCase;
+    };
+    extensions: string[];
+    pool: true;
+};

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

@@ -1,14 +1,6 @@
 import { snakeCase } from "es-toolkit";
-
-import { Config } from "@casekit/orm2-schema";
-
 import { models } from "./models/index.js";
-
 export { models } from "./models/index.js";
-
-export type Models = typeof models;
-export type Operators = { where: Record<symbol, never> };
-
 export const config = {
     schema: "orm",
     models,
@@ -18,4 +10,4 @@ export const config = {
     },
     extensions: ["uuid-ossp"],
     pool: true,
-} satisfies Config;
+};

package/build/models/audit.d.ts

@@ -0,0 +1,15 @@
+export declare const audit: {
+    readonly fields: {
+        readonly id: {
+            readonly type: "serial";
+            readonly primaryKey: true;
+        };
+        readonly change: {
+            readonly type: "text";
+            readonly provided: true;
+        };
+        readonly userId: {
+            readonly type: "integer";
+        };
+    };
+};

package/{src/models/audit.ts → build/models/audit.js}

@@ -1,9 +1,7 @@
-import { ModelDefinition } from "@casekit/orm2-schema";
-
 export const audit = {
     fields: {
         id: { type: "serial", primaryKey: true },
         change: { type: "text", provided: true },
         userId: { type: "integer" },
     },
-} as const satisfies ModelDefinition;
+};

package/build/models/color.d.ts

@@ -0,0 +1,11 @@
+export declare const color: {
+    readonly fields: {
+        readonly hex: {
+            readonly type: "text";
+            readonly primaryKey: true;
+        };
+        readonly name: {
+            readonly type: "text";
+        };
+    };
+};

package/{src/models/color.ts → build/models/color.js}

@@ -1,8 +1,6 @@
-import { ModelDefinition } from "@casekit/orm2-schema";
-
 export const color = {
     fields: {
         hex: { type: "text", primaryKey: true },
         name: { type: "text" },
     },
-} as const satisfies ModelDefinition;
+};

package/build/models/counter.d.ts

@@ -0,0 +1,8 @@
+export declare const counter: {
+    readonly fields: {
+        readonly counter: {
+            readonly type: "serial";
+            readonly primaryKey: true;
+        };
+    };
+};

package/build/models/counter.js

@@ -0,0 +1,3 @@
+export const counter = {
+    fields: { counter: { type: "serial", primaryKey: true } },
+};

package/build/models/friendship.d.ts

@@ -0,0 +1,32 @@
+export declare const friendship: {
+    readonly fields: {
+        readonly userId: {
+            readonly type: "integer";
+        };
+        readonly friendId: {
+            readonly type: "integer";
+        };
+    };
+    readonly primaryKey: ["userId", "friendId"];
+    readonly relations: {
+        readonly user: {
+            readonly type: "N:1";
+            readonly model: "user";
+            readonly fromField: "userId";
+            readonly toField: "id";
+        };
+        readonly friend: {
+            readonly type: "N:1";
+            readonly model: "user";
+            readonly fromField: "friendId";
+            readonly toField: "id";
+        };
+        readonly stats: {
+            readonly type: "N:1";
+            readonly model: "friendshipStats";
+            readonly fromField: ["userId", "friendId"];
+            readonly toField: ["userId", "friendId"];
+            readonly optional: true;
+        };
+    };
+};

package/{src/models/friendship.ts → build/models/friendship.js}

@@ -1,5 +1,3 @@
-import { ModelDefinition } from "@casekit/orm2-schema";
-
 export const friendship = {
     fields: {
         userId: { type: "integer" },
@@ -27,4 +25,4 @@ export const friendship = {
             optional: true,
         },
     },
-} as const satisfies ModelDefinition;
+};