@casekit/orm2-fixtures 0.0.1

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@casekit/orm2-fixtures",
+  "description": "",
+  "version": "0.0.1",
+  "author": "",
+  "dependencies": {
+    "es-toolkit": "^1.39.3",
+    "@casekit/orm2-schema": "0.0.1",
+    "@casekit/sql": "0.0.1",
+    "@casekit/orm2-config": "0.0.1"
+  },
+  "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",
+    "@casekit/tsconfig": "0.0.1",
+    "@casekit/prettier-config": "0.0.1"
+  },
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "/src"
+  ],
+  "imports": {
+    "#*": "./src/*"
+  },
+  "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",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/index.ts

@@ -0,0 +1,21 @@
+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,
+    naming: {
+        table: snakeCase,
+        column: snakeCase,
+    },
+    extensions: ["uuid-ossp"],
+    pool: true,
+} satisfies Config;

package/src/models/audit.ts

@@ -0,0 +1,9 @@
+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/src/models/color.ts

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

package/src/models/counter.ts

@@ -0,0 +1,5 @@
+import { ModelDefinition } from "@casekit/orm2-schema";
+
+export const counter = {
+    fields: { counter: { type: "serial", primaryKey: true } },
+} as const satisfies ModelDefinition;

package/src/models/friendship.ts

@@ -0,0 +1,30 @@
+import { ModelDefinition } from "@casekit/orm2-schema";
+
+export const friendship = {
+    fields: {
+        userId: { type: "integer" },
+        friendId: { type: "integer" },
+    },
+    primaryKey: ["userId", "friendId"],
+    relations: {
+        user: {
+            type: "N:1",
+            model: "user",
+            fromField: "userId",
+            toField: "id",
+        },
+        friend: {
+            type: "N:1",
+            model: "user",
+            fromField: "friendId",
+            toField: "id",
+        },
+        stats: {
+            type: "N:1",
+            model: "friendshipStats",
+            fromField: ["userId", "friendId"],
+            toField: ["userId", "friendId"],
+            optional: true,
+        },
+    },
+} as const satisfies ModelDefinition;

package/src/models/friendshipStats.ts

@@ -0,0 +1,29 @@
+import { ModelDefinition } from "@casekit/orm2-schema";
+
+export const friendshipStats = {
+    fields: {
+        id: { type: "serial", primaryKey: true },
+        userId: { type: "integer" },
+        friendId: { type: "integer" },
+        messagesSent: { type: "integer", default: 0 },
+        likesGiven: { type: "integer", default: 0 },
+    },
+    foreignKeys: [
+        {
+            fields: ["userId", "friendId"],
+            references: {
+                model: "friendship",
+                fields: ["userId", "friendId"],
+            },
+            onDelete: "CASCADE",
+        },
+    ],
+    relations: {
+        friendship: {
+            type: "N:1",
+            model: "friendship",
+            fromField: ["userId", "friendId"],
+            toField: ["userId", "friendId"],
+        },
+    },
+} as const satisfies ModelDefinition;

package/src/models/index.ts

@@ -0,0 +1,21 @@
+import { audit } from "./audit.js";
+import { color } from "./color.js";
+import { counter } from "./counter.js";
+import { friendship } from "./friendship.js";
+import { friendshipStats } from "./friendshipStats.js";
+import { kitchenSink } from "./kitchenSink.js";
+import { like } from "./like.js";
+import { post } from "./post.js";
+import { user } from "./user.js";
+
+export const models = {
+    audit,
+    counter,
+    user,
+    post,
+    like,
+    color,
+    friendship,
+    friendshipStats,
+    kitchenSink,
+};

package/src/models/kitchenSink.ts

@@ -0,0 +1,77 @@
+import { ModelDefinition } from "@casekit/orm2-schema";
+
+export const kitchenSink = {
+    fields: {
+        id: { type: "serial", primaryKey: true },
+        charField: { type: "char" },
+        characterField: { type: "character" },
+        characterNField: { type: "character(24)" },
+        varcharField: { type: "character varying" },
+        varcharNField: { type: "character varying(24)" },
+        textField: { type: "text" },
+        bitField: { type: "bit" },
+        bitNField: { type: "bit(3)" },
+        bitVaryingField: { type: "bit varying" },
+        bitVaryingNField: { type: "bit varying(3)" },
+        numericField: { type: "numeric" },
+        numericPrecisionField: { type: "numeric(5,2)" },
+        integerField: { type: "integer" },
+        bigintField: { type: "bigint" },
+        smallintField: { type: "smallint" },
+        serialField: { type: "serial" },
+        bigserialField: { type: "bigserial" },
+        smallserialField: { type: "smallserial" },
+        doublePrecisionField: { type: "double precision" },
+        realField: { type: "real" },
+        moneyField: { type: "money" },
+        booleanField: { type: "boolean" },
+        uuidField: { type: "uuid" },
+        dateField: { type: "date" },
+        timeField: { type: "time" },
+        timeWithPrecisionField: { type: "time(3)" },
+        timetzField: { type: "timetz" },
+        timeWithTzField: { type: "time with time zone" },
+        timestampField: { type: "timestamp" },
+        timestampWithPrecisionField: { type: "timestamp(6)" },
+        timestamptzField: { type: "timestamptz" },
+        timestampWithTzField: { type: "timestamp with time zone" },
+        // intervalField: { type: "interval" },
+        jsonField: { type: "json" },
+        jsonbField: { type: "jsonb" },
+        // pointField: { type: "point" },
+        lineField: { type: "line" },
+        lsegField: { type: "lseg" },
+        boxField: { type: "box" },
+        polygonField: { type: "polygon" },
+        // circleField: { type: "circle" },
+        cidrField: { type: "cidr" },
+        inetField: { type: "inet" },
+        macaddrField: { type: "macaddr" },
+        macaddr8Field: { type: "macaddr8" },
+        byteaField: { type: "bytea" },
+        xmlField: { type: "xml" },
+        pathField: { type: "path" },
+        tsqueryField: { type: "tsquery" },
+        tsvectorField: { type: "tsvector" },
+        int4rangeField: { type: "int4range" },
+        int8rangeField: { type: "int8range" },
+        numrangeField: { type: "numrange" },
+        tsrangeField: { type: "tsrange" },
+        tstzrangeField: { type: "tstzrange" },
+        daterangeField: { type: "daterange" },
+        int2vectorField: { type: "int2vector" },
+        oidField: { type: "oid" },
+        pglsnField: { type: "pg_lsn" },
+        regclassField: { type: "regclass" },
+        regnamespaceField: { type: "regnamespace" },
+        regprocField: { type: "regproc" },
+        regprocedureField: { type: "regprocedure" },
+        regroleField: { type: "regrole" },
+        regtypeField: { type: "regtype" },
+        tidField: { type: "tid" },
+        xidField: { type: "xid" },
+        txidSnapshotField: { type: "txid_snapshot" },
+        arrayField: { type: "text[]" },
+        multiArrayField: { type: "text[][][]" },
+    },
+} as const satisfies ModelDefinition;

package/src/models/like.ts

@@ -0,0 +1,43 @@
+import { ModelDefinition } from "@casekit/orm2-schema";
+import { sql } from "@casekit/sql";
+
+export const like = {
+    fields: {
+        id: { type: "serial", primaryKey: true },
+        userId: {
+            type: "integer",
+            references: {
+                model: "user",
+                field: "id",
+                onDelete: "CASCADE",
+            },
+        },
+        postId: {
+            type: "integer",
+            references: {
+                model: "post",
+                field: "id",
+                onDelete: "CASCADE",
+            },
+        },
+        createdAt: { type: "timestamp", default: sql`now()` },
+        deletedAt: { type: "timestamp", nullable: true },
+    },
+    uniqueConstraints: [
+        { fields: ["userId", "postId"], where: sql`deleted_at IS NULL` },
+    ],
+    relations: {
+        user: {
+            type: "N:1",
+            model: "user",
+            fromField: "userId",
+            toField: "id",
+        },
+        post: {
+            type: "N:1",
+            model: "post",
+            fromField: "postId",
+            toField: "id",
+        },
+    },
+} as const satisfies ModelDefinition;

package/src/models/post.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+
+import { ModelDefinition } from "@casekit/orm2-schema";
+import { sql } from "@casekit/sql";
+
+export const post = {
+    fields: {
+        id: { type: "serial", primaryKey: true },
+        title: { type: "text" },
+        content: { type: "text" },
+        tags: { type: "text[]", default: "{}" },
+        authorId: {
+            type: "integer",
+            references: {
+                model: "user",
+                field: "id",
+            },
+        },
+        backgroundColorValue: {
+            type: "text",
+            nullable: true,
+            references: {
+                model: "color",
+                field: "hex",
+                onDelete: "SET NULL",
+            },
+        },
+        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(),
+                    }),
+                ),
+            }),
+        },
+        createdAt: { type: "timestamp", default: sql`now()` },
+        publishedAt: { type: "timestamp", nullable: true },
+        deletedAt: { type: "timestamp", nullable: true },
+    },
+    relations: {
+        author: {
+            type: "N:1",
+            model: "user",
+            fromField: "authorId",
+            toField: "id",
+        },
+        backgroundColor: {
+            type: "N:1",
+            model: "color",
+            fromField: "backgroundColorValue",
+            toField: "hex",
+            optional: true,
+        },
+        likes: {
+            type: "1:N",
+            model: "like",
+            fromField: "id",
+            toField: "postId",
+        },
+    },
+} as const satisfies ModelDefinition;

package/src/models/user.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+
+import { ModelDefinition } from "@casekit/orm2-schema";
+import { sql } from "@casekit/sql";
+
+export const user = {
+    fields: {
+        id: { type: "serial", primaryKey: true },
+        name: { type: "text" },
+        email: { type: "text", zodSchema: z.email() },
+        role: { type: "text", zodSchema: z.enum(["user", "admin"]) },
+        preferences: { type: "jsonb", default: "{}" },
+        createdAt: { type: "timestamp", default: sql`now()` },
+        deletedAt: { type: "timestamp", nullable: true },
+    },
+    uniqueConstraints: [
+        { fields: ["email", "deletedAt"], nullsNotDistinct: true },
+    ],
+    relations: {
+        posts: {
+            type: "1:N",
+            model: "post",
+            fromField: "id",
+            toField: "authorId",
+        },
+        friends: {
+            type: "N:N",
+            model: "user",
+            through: {
+                model: "friendship",
+                fromRelation: "user",
+                toRelation: "friend",
+            },
+        },
+        friendships: {
+            type: "1:N",
+            model: "friendship",
+            fromField: "id",
+            toField: "userId",
+        },
+    },
+} as const satisfies ModelDefinition;