@house-rules/relations 0.0.0-stage → 0.1.1

package/dist/relation/relation.d.ts

@@ -0,0 +1,169 @@
+import { Schema } from "effect";
+export declare const NodeRef: Schema.Struct<{
+    readonly kind: Schema.NonEmptyString;
+    readonly id: Schema.NonEmptyString;
+}>;
+export type NodeRef = typeof NodeRef.Type;
+export declare const RelationDirection: Schema.Literals<readonly ["out", "in", "both"]>;
+export type RelationDirection = typeof RelationDirection.Type;
+export declare const RelationCursor: Schema.Struct<{
+    readonly createdAt: Schema.Int;
+    readonly id: Schema.NonEmptyString;
+}>;
+export type RelationCursor = typeof RelationCursor.Type;
+export declare const RelationPage: Schema.Struct<{
+    readonly size: Schema.optionalKey<Schema.Int>;
+    readonly cursor: Schema.optionalKey<Schema.Struct<{
+        readonly createdAt: Schema.Int;
+        readonly id: Schema.NonEmptyString;
+    }>>;
+}>;
+export type RelationPage = typeof RelationPage.Type;
+export declare const Relation: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly type: Schema.NonEmptyString;
+    readonly source: Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly target: Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly createdAt: Schema.Int;
+}>;
+export type Relation = typeof Relation.Type;
+export declare const RelateInput: Schema.Struct<{
+    readonly type: Schema.NonEmptyString;
+    readonly source: Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly target: Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+}>;
+export type RelateInput = typeof RelateInput.Type;
+export declare const ListRelationsInput: Schema.Struct<{
+    readonly node: Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly type: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly direction: Schema.Literals<readonly ["out", "in", "both"]>;
+    readonly page: Schema.optionalKey<Schema.Struct<{
+        readonly size: Schema.optionalKey<Schema.Int>;
+        readonly cursor: Schema.optionalKey<Schema.Struct<{
+            readonly createdAt: Schema.Int;
+            readonly id: Schema.NonEmptyString;
+        }>>;
+    }>>;
+}>;
+export type ListRelationsInput = typeof ListRelationsInput.Type;
+export declare const RelationList: Schema.Struct<{
+    readonly edges: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly type: Schema.NonEmptyString;
+        readonly source: Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly target: Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly createdAt: Schema.Int;
+    }>>;
+    readonly next: Schema.optionalKey<Schema.Struct<{
+        readonly createdAt: Schema.Int;
+        readonly id: Schema.NonEmptyString;
+    }>>;
+}>;
+export type RelationList = typeof RelationList.Type;
+export declare const SubgraphInput: Schema.Struct<{
+    readonly root: Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly type: Schema.NonEmptyString;
+    readonly direction: Schema.Literals<readonly ["out", "in", "both"]>;
+    readonly depth: Schema.optionalKey<Schema.Int>;
+}>;
+export type SubgraphInput = typeof SubgraphInput.Type;
+export declare const RelationGraph: Schema.Struct<{
+    readonly nodes: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>>;
+    readonly edges: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly type: Schema.NonEmptyString;
+        readonly source: Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly target: Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly createdAt: Schema.Int;
+    }>>;
+}>;
+export type RelationGraph = typeof RelationGraph.Type;
+declare const RelationTypeUnknown_base: Schema.Class<RelationTypeUnknown, Schema.TaggedStruct<"RelationTypeUnknown", {
+    readonly kind: Schema.tag<"invalid">;
+}>, import("effect/Cause").YieldableError>;
+export declare class RelationTypeUnknown extends RelationTypeUnknown_base {
+    get message(): string;
+}
+declare const RelationEndpointInvalid_base: Schema.Class<RelationEndpointInvalid, Schema.TaggedStruct<"RelationEndpointInvalid", {
+    readonly kind: Schema.tag<"invalid">;
+}>, import("effect/Cause").YieldableError>;
+export declare class RelationEndpointInvalid extends RelationEndpointInvalid_base {
+    get message(): string;
+}
+declare const RelationsInputInvalid_base: Schema.Class<RelationsInputInvalid, Schema.TaggedStruct<"RelationsInputInvalid", {
+    readonly kind: Schema.tag<"invalid">;
+}>, import("effect/Cause").YieldableError>;
+export declare class RelationsInputInvalid extends RelationsInputInvalid_base {
+    get message(): string;
+}
+declare const DuplicateRelation_base: Schema.Class<DuplicateRelation, Schema.TaggedStruct<"DuplicateRelation", {
+    readonly kind: Schema.tag<"conflict">;
+}>, import("effect/Cause").YieldableError>;
+export declare class DuplicateRelation extends DuplicateRelation_base {
+    get message(): string;
+}
+declare const RelationCardinalityExceeded_base: Schema.Class<RelationCardinalityExceeded, Schema.TaggedStruct<"RelationCardinalityExceeded", {
+    readonly kind: Schema.tag<"conflict">;
+}>, import("effect/Cause").YieldableError>;
+export declare class RelationCardinalityExceeded extends RelationCardinalityExceeded_base {
+    get message(): string;
+}
+declare const RelationCycle_base: Schema.Class<RelationCycle, Schema.TaggedStruct<"RelationCycle", {
+    readonly kind: Schema.tag<"conflict">;
+}>, import("effect/Cause").YieldableError>;
+export declare class RelationCycle extends RelationCycle_base {
+    get message(): string;
+}
+declare const RelationNotFound_base: Schema.Class<RelationNotFound, Schema.TaggedStruct<"RelationNotFound", {
+    readonly kind: Schema.tag<"not_found">;
+}>, import("effect/Cause").YieldableError>;
+export declare class RelationNotFound extends RelationNotFound_base {
+    get message(): string;
+}
+declare const GraphTooLarge_base: Schema.Class<GraphTooLarge, Schema.TaggedStruct<"GraphTooLarge", {
+    readonly kind: Schema.tag<"invalid">;
+}>, import("effect/Cause").YieldableError>;
+export declare class GraphTooLarge extends GraphTooLarge_base {
+    get message(): string;
+}
+declare const RelationsStoreUnavailable_base: Schema.Class<RelationsStoreUnavailable, Schema.TaggedStruct<"RelationsStoreUnavailable", {
+    readonly kind: Schema.tag<"unavailable">;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class RelationsStoreUnavailable extends RelationsStoreUnavailable_base {
+    get message(): string;
+}
+export {};

package/dist/relation/relation.js

@@ -0,0 +1,105 @@
+import { errorKind } from "@house-rules/domain/contract";
+import { Schema } from "effect";
+export const NodeRef = Schema.Struct({ kind: Schema.NonEmptyString, id: Schema.NonEmptyString });
+export const RelationDirection = Schema.Literals(["out", "in", "both"]);
+export const RelationCursor = Schema.Struct({ createdAt: Schema.Int, id: Schema.NonEmptyString });
+export const RelationPage = Schema.Struct({
+    size: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0))),
+    cursor: Schema.optionalKey(RelationCursor),
+});
+export const Relation = Schema.Struct({
+    id: Schema.NonEmptyString,
+    type: Schema.NonEmptyString,
+    source: NodeRef,
+    target: NodeRef,
+    createdAt: Schema.Int,
+});
+export const RelateInput = Schema.Struct({
+    type: Schema.NonEmptyString,
+    source: NodeRef,
+    target: NodeRef,
+});
+export const ListRelationsInput = Schema.Struct({
+    node: NodeRef,
+    type: Schema.optionalKey(Schema.NonEmptyString),
+    direction: RelationDirection,
+    page: Schema.optionalKey(RelationPage),
+});
+export const RelationList = Schema.Struct({
+    edges: Schema.Array(Relation),
+    next: Schema.optionalKey(RelationCursor),
+});
+export const SubgraphInput = Schema.Struct({
+    root: NodeRef,
+    type: Schema.NonEmptyString,
+    direction: RelationDirection,
+    depth: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
+});
+export const RelationGraph = Schema.Struct({
+    nodes: Schema.Array(NodeRef),
+    edges: Schema.Array(Relation),
+});
+export class RelationTypeUnknown extends Schema.TaggedError()("RelationTypeUnknown", {
+    kind: errorKind("invalid"),
+}) {
+    get message() {
+        return "Unknown relation type.";
+    }
+}
+export class RelationEndpointInvalid extends Schema.TaggedError()("RelationEndpointInvalid", {
+    kind: errorKind("invalid"),
+}) {
+    get message() {
+        return "Invalid relation endpoint.";
+    }
+}
+export class RelationsInputInvalid extends Schema.TaggedError()("RelationsInputInvalid", {
+    kind: errorKind("invalid"),
+}) {
+    get message() {
+        return "Invalid relations input or options.";
+    }
+}
+export class DuplicateRelation extends Schema.TaggedError()("DuplicateRelation", {
+    kind: errorKind("conflict"),
+}) {
+    get message() {
+        return "This relation already exists.";
+    }
+}
+export class RelationCardinalityExceeded extends Schema.TaggedError()("RelationCardinalityExceeded", {
+    kind: errorKind("conflict"),
+}) {
+    get message() {
+        return "Relation cardinality exceeded.";
+    }
+}
+export class RelationCycle extends Schema.TaggedError()("RelationCycle", {
+    kind: errorKind("conflict"),
+}) {
+    get message() {
+        return "This relation would create a cycle.";
+    }
+}
+export class RelationNotFound extends Schema.TaggedError()("RelationNotFound", {
+    kind: errorKind("not_found"),
+}) {
+    get message() {
+        return "Relation not found.";
+    }
+}
+export class GraphTooLarge extends Schema.TaggedError()("GraphTooLarge", {
+    kind: errorKind("invalid"),
+}) {
+    get message() {
+        return "The relation graph exceeds its configured size limit.";
+    }
+}
+export class RelationsStoreUnavailable extends Schema.TaggedError()("RelationsStoreUnavailable", {
+    kind: errorKind("unavailable"),
+    cause: Schema.Defect(),
+}) {
+    get message() {
+        return "Relations are unavailable. Try again shortly.";
+    }
+}

package/dist/relation/relations.d.ts

@@ -0,0 +1,136 @@
+import { Effect } from "effect";
+import type { RelationStore } from "../storage.js";
+import type { RelationsOptions } from "./options.js";
+import { DuplicateRelation, GraphTooLarge, RelationCardinalityExceeded, RelationCycle, RelationEndpointInvalid, RelationNotFound, RelationsInputInvalid, RelationTypeUnknown } from "./relation.js";
+export declare const makeRelations: (store: RelationStore["Service"], options: RelationsOptions) => {
+    relate: (input: {
+        readonly type: string;
+        readonly source: {
+            readonly kind: string;
+            readonly id: string;
+        };
+        readonly target: {
+            readonly kind: string;
+            readonly id: string;
+        };
+    }) => Effect.Effect<{
+        relation: {
+            readonly id: string;
+            readonly type: string;
+            readonly source: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            readonly target: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            readonly createdAt: number;
+        };
+        events: {
+            kind: "Related";
+            type: string;
+            source: {
+                kind: string;
+                id: string;
+            };
+            target: {
+                kind: string;
+                id: string;
+            };
+        }[];
+    }, DuplicateRelation | GraphTooLarge | import("@house-rules/domain").NoOpenUnit | RelationCardinalityExceeded | RelationCycle | RelationEndpointInvalid | RelationTypeUnknown | import("./relation.js").RelationsStoreUnavailable, never>;
+    unrelate: (id: string) => Effect.Effect<{
+        events: {
+            kind: "Unrelated";
+            type: string;
+            source: {
+                kind: string;
+                id: string;
+            };
+            target: {
+                kind: string;
+                id: string;
+            };
+        }[];
+    }, import("@house-rules/domain").NoOpenUnit | RelationNotFound | import("./relation.js").RelationsStoreUnavailable, never>;
+    listRelations: (input: {
+        readonly node: {
+            readonly kind: string;
+            readonly id: string;
+        };
+        readonly type?: string;
+        readonly direction: "both" | "in" | "out";
+        readonly page?: {
+            readonly size?: number;
+            readonly cursor?: {
+                readonly createdAt: number;
+                readonly id: string;
+            };
+        };
+    }) => Effect.Effect<{
+        edges: {
+            readonly id: string;
+            readonly type: string;
+            readonly source: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            readonly target: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            readonly createdAt: number;
+        }[];
+        next: {
+            createdAt: number;
+            id: string;
+        };
+    } | {
+        next?: never;
+        edges: {
+            readonly id: string;
+            readonly type: string;
+            readonly source: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            readonly target: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            readonly createdAt: number;
+        }[];
+    }, RelationEndpointInvalid | RelationTypeUnknown | RelationsInputInvalid | import("./relation.js").RelationsStoreUnavailable, never>;
+    subgraph: (input: {
+        readonly root: {
+            readonly kind: string;
+            readonly id: string;
+        };
+        readonly type: string;
+        readonly direction: "both" | "in" | "out";
+        readonly depth?: number;
+    }) => Effect.Effect<{
+        nodes: {
+            kind: string;
+            id: string;
+        }[];
+        edges: {
+            readonly id: string;
+            readonly type: string;
+            readonly source: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            readonly target: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            readonly createdAt: number;
+        }[];
+    }, GraphTooLarge | RelationEndpointInvalid | RelationTypeUnknown | RelationsInputInvalid | import("./relation.js").RelationsStoreUnavailable, never>;
+    removeNode: (ref: {
+        readonly kind: string;
+        readonly id: string;
+    }) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | RelationEndpointInvalid | import("./relation.js").RelationsStoreUnavailable, never>;
+};

package/dist/relation/relations.js

@@ -0,0 +1,135 @@
+import { UnitOfWork } from "@house-rules/domain";
+import { DateTime, Effect, Random, Schema } from "effect";
+import { compareNodes, neighbours, nodeKey, sameNode } from "./graph.js";
+import { DuplicateRelation, GraphTooLarge, ListRelationsInput, NodeRef, RelationCardinalityExceeded, RelationCycle, RelationEndpointInvalid, RelationNotFound, RelationsInputInvalid, RelationTypeUnknown, SubgraphInput, } from "./relation.js";
+export const makeRelations = (store, options) => {
+    const invalid = () => new RelationsInputInvalid();
+    const decodeNode = (node) => Schema.decodeEffect(Schema.Struct({
+        kind: Schema.Literals(options.nodeKinds),
+        id: NodeRef.fields.id,
+    }))(node).pipe(Effect.mapError(() => new RelationEndpointInvalid()));
+    const getType = Effect.fn("Relations.type")(function* (name) {
+        const type = options.relationTypes.find((type) => type.name === name);
+        if (type === undefined)
+            return yield* new RelationTypeUnknown();
+        return type;
+    });
+    const checkCap = Effect.fn("Relations.cardinality")(function* (node, type, direction, cap) {
+        if (cap !== undefined && (yield* store.count(node, type, direction)) >= cap)
+            return yield* new RelationCardinalityExceeded();
+    });
+    return {
+        relate: Effect.fn("Relations.relate")(function* (input) {
+            yield* UnitOfWork.required;
+            const type = yield* getType(input.type);
+            let source = yield* decodeNode(input.source);
+            let target = yield* decodeNode(input.target);
+            const forward = type.source.includes(source.kind) && type.target.includes(target.kind);
+            const reverse = !type.directed && type.source.includes(target.kind) && type.target.includes(source.kind);
+            if (!forward && !reverse)
+                return yield* new RelationEndpointInvalid();
+            if (!type.directed && compareNodes(source, target) > 0)
+                [source, target] = [target, source];
+            yield* store.lock(type.name);
+            if (type.unique && (yield* store.exists(source, target, type.name)))
+                return yield* new DuplicateRelation();
+            if (type.directed) {
+                yield* checkCap(source, type.name, "out", type.maxOutPerSource);
+                yield* checkCap(target, type.name, "in", type.maxInPerTarget);
+            }
+            else {
+                yield* checkCap(source, type.name, "both", type.maxDegree);
+                if (!sameNode(source, target))
+                    yield* checkCap(target, type.name, "both", type.maxDegree);
+            }
+            if (type.acyclic) {
+                const reached = yield* store.reachable(target, type.name, options.maxGraphSize + 1);
+                if (reached.length > options.maxGraphSize)
+                    return yield* new GraphTooLarge();
+                if (reached.some((node) => sameNode(source, node)))
+                    return yield* new RelationCycle();
+            }
+            const edge = {
+                id: yield* Effect.all(Array.from({ length: 4 }, () => Random.nextIntBetween(0, 0xffff_ffff))).pipe(Effect.map((words) => words.map((word) => word.toString(16).padStart(8, "0")).join(""))),
+                type: type.name,
+                source: { ...source },
+                target: { ...target },
+                createdAt: DateTime.toEpochMillis(yield* DateTime.now),
+            };
+            yield* store.insert(edge);
+            return {
+                relation: edge,
+                events: [
+                    {
+                        kind: "Related",
+                        type: edge.type,
+                        source: { ...edge.source },
+                        target: { ...edge.target },
+                    },
+                ],
+            };
+        }),
+        unrelate: Effect.fn("Relations.unrelate")(function* (id) {
+            yield* UnitOfWork.required;
+            const edge = yield* store.remove(id);
+            if (edge === undefined)
+                return yield* new RelationNotFound();
+            return {
+                events: [
+                    {
+                        kind: "Unrelated",
+                        type: edge.type,
+                        source: { ...edge.source },
+                        target: { ...edge.target },
+                    },
+                ],
+            };
+        }),
+        listRelations: Effect.fn("Relations.listRelations")(function* (input) {
+            yield* decodeNode(input.node);
+            const decoded = yield* Schema.decodeEffect(ListRelationsInput)(input).pipe(Effect.mapError(invalid));
+            if (decoded.type !== undefined)
+                yield* getType(decoded.type);
+            const size = Math.min(decoded.page?.size ?? options.maxPageSize, options.maxPageSize);
+            const rows = yield* store.list(decoded.node, decoded.type, decoded.direction, size + 1, decoded.page?.cursor);
+            const edges = rows.slice(0, size);
+            const last = edges[edges.length - 1];
+            return rows.length > size && last !== undefined
+                ? { edges, next: { createdAt: last.createdAt, id: last.id } }
+                : { edges };
+        }),
+        subgraph: Effect.fn("Relations.subgraph")(function* (input) {
+            yield* decodeNode(input.root);
+            const decoded = yield* Schema.decodeEffect(SubgraphInput)(input).pipe(Effect.mapError(invalid));
+            yield* getType(decoded.type);
+            const nodes = new Map([[nodeKey(decoded.root), { ...decoded.root }]]);
+            const edges = new Map();
+            const queue = [{ node: decoded.root, depth: 0 }];
+            for (let i = 0; i < queue.length; i++) {
+                const current = queue[i];
+                if (current === undefined ||
+                    (decoded.depth !== undefined && current.depth >= decoded.depth))
+                    continue;
+                const adjacent = yield* store.list(current.node, decoded.type, decoded.direction, options.maxGraphSize + 1);
+                for (const edge of adjacent) {
+                    edges.set(edge.id, edge);
+                    for (const next of neighbours(edge, current.node, decoded.direction)) {
+                        if (nodes.has(nodeKey(next)))
+                            continue;
+                        nodes.set(nodeKey(next), { ...next });
+                        queue.push({ node: next, depth: current.depth + 1 });
+                    }
+                    if (nodes.size > options.maxGraphSize || edges.size > options.maxGraphSize)
+                        return yield* new GraphTooLarge();
+                }
+            }
+            return { nodes: [...nodes.values()], edges: [...edges.values()] };
+        }),
+        // Node deletion is a fact owned by the node's module, not an Unrelated event.
+        removeNode: Effect.fn("Relations.removeNode")(function* (ref) {
+            yield* UnitOfWork.required;
+            const node = yield* Schema.decodeEffect(NodeRef)(ref).pipe(Effect.mapError(() => new RelationEndpointInvalid()));
+            yield* store.removeNode(node);
+        }),
+    };
+};

package/dist/storage.d.ts

@@ -0,0 +1,18 @@
+import type { NoOpenUnit } from "@house-rules/domain";
+import { Context, type Effect } from "effect";
+import type { NodeRef, Relation, RelationCursor, RelationDirection, RelationsStoreUnavailable } from "./relation/relation.js";
+type Read<A> = Effect.Effect<A, RelationsStoreUnavailable>;
+type Write<A> = Effect.Effect<A, RelationsStoreUnavailable | NoOpenUnit>;
+declare const RelationStore_base: Context.ServiceClass<RelationStore, "@house-rules/relations/RelationStore", {
+    readonly lock: (type: string) => Write<void>;
+    readonly list: (node: NodeRef, type: string | undefined, direction: RelationDirection, size: number, after?: RelationCursor) => Read<ReadonlyArray<Relation>>;
+    readonly count: (node: NodeRef, type: string, direction: RelationDirection) => Read<number>;
+    readonly exists: (source: NodeRef, target: NodeRef, type: string) => Read<boolean>;
+    readonly reachable: (root: NodeRef, type: string, limit: number) => Read<ReadonlyArray<NodeRef>>;
+    readonly insert: (edge: Relation) => Write<void>;
+    readonly remove: (id: string) => Write<Relation | undefined>;
+    readonly removeNode: (node: NodeRef) => Write<void>;
+}>;
+export declare class RelationStore extends RelationStore_base {
+}
+export {};

package/dist/storage.js

@@ -0,0 +1,3 @@
+import { Context } from "effect";
+export class RelationStore extends Context.Service()("@house-rules/relations/RelationStore") {
+}

package/migrations/0001_relations.sql

@@ -0,0 +1,17 @@
+CREATE TABLE relation_edges (
+  id text PRIMARY KEY,
+  type text NOT NULL,
+  source_kind text NOT NULL,
+  source_id text NOT NULL,
+  target_kind text NOT NULL,
+  target_id text NOT NULL,
+  created_at bigint NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX relation_edges_source ON relation_edges (type, source_kind, source_id);
+--> statement-breakpoint
+CREATE INDEX relation_edges_target ON relation_edges (type, target_kind, target_id);
+--> statement-breakpoint
+CREATE INDEX relation_edges_source_page ON relation_edges (source_kind, source_id, created_at, id COLLATE "C");
+--> statement-breakpoint
+CREATE INDEX relation_edges_target_page ON relation_edges (target_kind, target_id, created_at, id COLLATE "C");

package/package.json

@@ -1,6 +1,60 @@
 {
   "name": "@house-rules/relations",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Typed, non-authority edges between opaque nodes.",
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "dist",
+    "migrations",
+    "AGENTS.md",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./contract": {
+      "types": "./dist/contract.d.ts",
+      "default": "./dist/contract.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JakubSzwajka/house-rules.git",
+    "directory": "packages/relations"
+  },
+  "bugs": {
+    "url": "https://github.com/JakubSzwajka/house-rules/issues"
+  },
+  "homepage": "https://github.com/JakubSzwajka/house-rules",
+  "houseRules": {
+    "migrations": "migrations"
+  },
+  "peerDependencies": {
+    "@house-rules/application": "0.3.0",
+    "@house-rules/domain": "0.2.1",
+    "effect": "4.0.3"
+  },
+  "devDependencies": {
+    "@effect/platform-node": "4.0.3",
+    "@effect/platform-node-shared": "4.0.3",
+    "@effect/sql-pg": "4.0.3",
+    "@effect/vitest": "4.0.3",
+    "@house-rules/application": "0.3.0",
+    "@house-rules/domain": "0.2.1",
+    "@house-rules/migrations": "0.4.1",
+    "effect": "4.0.3",
+    "typescript": "7.0.2",
+    "vitest": "5.0.1"
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "typecheck": "tsc --project tsconfig.json",
+    "test": "varlock run --path ../../ -- vitest run"
+  }
 }