@house-rules/relations 0.0.0-stage → 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,128 @@
+import { Relations } from "./facade.js";
+import { bindRelations } from "./relation/bind-relations.js";
+export declare const RelationsMount: {
+    map: {
+        name: string;
+        kind: "package";
+        package: string;
+    };
+    service: typeof Relations;
+    operations: (import("@house-rules/domain").Operation<"Relations.listRelations", import("effect/Schema").Struct<{
+        readonly node: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").NonEmptyString;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>;
+        readonly type: import("effect/Schema").optionalKey<import("effect/Schema").NonEmptyString>;
+        readonly direction: import("effect/Schema").Literals<readonly ["out", "in", "both"]>;
+        readonly page: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+            readonly size: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
+            readonly cursor: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+                readonly createdAt: import("effect/Schema").Int;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>>;
+        }>>;
+    }>, import("effect/Schema").Struct<{
+        readonly edges: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly id: import("effect/Schema").NonEmptyString;
+            readonly type: import("effect/Schema").NonEmptyString;
+            readonly source: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+            readonly target: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+            readonly createdAt: import("effect/Schema").Int;
+        }>>;
+        readonly next: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+            readonly createdAt: import("effect/Schema").Int;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>>;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").RelationTypeUnknown, typeof import("./contract.js").RelationEndpointInvalid, typeof import("./contract.js").RelationsInputInvalid, typeof import("./contract.js").RelationsStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Relations.relate", import("effect/Schema").Struct<{
+        readonly type: import("effect/Schema").NonEmptyString;
+        readonly source: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").NonEmptyString;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>;
+        readonly target: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").NonEmptyString;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>;
+    }>, import("effect/Schema").Struct<{
+        readonly relation: import("effect/Schema").Struct<{
+            readonly id: import("effect/Schema").NonEmptyString;
+            readonly type: import("effect/Schema").NonEmptyString;
+            readonly source: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+            readonly target: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+            readonly createdAt: import("effect/Schema").Int;
+        }>;
+        readonly events: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").NonEmptyString;
+            readonly source: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+            readonly target: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+            readonly kind: import("effect/Schema").Literal<"Related">;
+        }>>;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").RelationTypeUnknown, typeof import("./contract.js").RelationEndpointInvalid, typeof import("./contract.js").DuplicateRelation, typeof import("./contract.js").RelationCardinalityExceeded, typeof import("./contract.js").RelationCycle, typeof import("./contract.js").GraphTooLarge, typeof import("./contract.js").RelationsStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Relations.subgraph", import("effect/Schema").Struct<{
+        readonly root: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").NonEmptyString;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>;
+        readonly type: import("effect/Schema").NonEmptyString;
+        readonly direction: import("effect/Schema").Literals<readonly ["out", "in", "both"]>;
+        readonly depth: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
+    }>, import("effect/Schema").Struct<{
+        readonly nodes: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").NonEmptyString;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>>;
+        readonly edges: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly id: import("effect/Schema").NonEmptyString;
+            readonly type: import("effect/Schema").NonEmptyString;
+            readonly source: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+            readonly target: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+            readonly createdAt: import("effect/Schema").Int;
+        }>>;
+    }>, import("effect/Schema").Union<readonly [import("effect/Schema").Union<readonly [typeof import("./contract.js").RelationTypeUnknown, typeof import("./contract.js").RelationEndpointInvalid, typeof import("./contract.js").RelationsInputInvalid, typeof import("./contract.js").RelationsStoreUnavailable]>, typeof import("./contract.js").GraphTooLarge]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Relations.unrelate", import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").NonEmptyString;
+    }>, import("effect/Schema").Struct<{
+        readonly events: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").NonEmptyString;
+            readonly source: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+            readonly target: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+            readonly kind: import("effect/Schema").Literal<"Unrelated">;
+        }>>;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").RelationNotFound, typeof import("./contract.js").RelationsStoreUnavailable]>, NoInfer<readonly []>, false, true, true, false>)[];
+    bind: typeof bindRelations;
+};
+export { Relations } from "./facade.js";
+export { bindRelations } from "./relation/bind-relations.js";
+export { RelationsOptions, RelationType } from "./relation/options.js";
+export { RelationStore } from "./storage.js";
+export { memoryRelationStore } from "./adapters/memory/relation.js";
+export { postgresRelationStore } from "./adapters/postgres/relation.js";
+export { RelateResult, RelationEvents, UnrelateResult, DuplicateRelation, GraphTooLarge, ListRelationsInput, NodeRef, RelateInput, Relation, RelationCardinalityExceeded, RelationCursor, RelationCycle, RelationDirection, RelationEndpointInvalid, RelationGraph, RelationList, RelationNotFound, RelationPage, RelationsInputInvalid, RelationsStoreUnavailable, RelationTypeUnknown, SubgraphInput, RelationsOperations, RelationsPermissions, type RelationsPermission, } from "./contract.js";

package/dist/index.js

@@ -0,0 +1,16 @@
+import { Relations } from "./facade.js";
+import { RelationsOperations } from "./contract.js";
+import { bindRelations } from "./relation/bind-relations.js";
+export const RelationsMount = {
+    map: { name: "relations", kind: "package", package: "@house-rules/relations" },
+    service: Relations,
+    operations: Object.values(RelationsOperations),
+    bind: bindRelations,
+};
+export { Relations } from "./facade.js";
+export { bindRelations } from "./relation/bind-relations.js";
+export { RelationsOptions, RelationType } from "./relation/options.js";
+export { RelationStore } from "./storage.js";
+export { memoryRelationStore } from "./adapters/memory/relation.js";
+export { postgresRelationStore } from "./adapters/postgres/relation.js";
+export { RelateResult, RelationEvents, UnrelateResult, DuplicateRelation, GraphTooLarge, ListRelationsInput, NodeRef, RelateInput, Relation, RelationCardinalityExceeded, RelationCursor, RelationCycle, RelationDirection, RelationEndpointInvalid, RelationGraph, RelationList, RelationNotFound, RelationPage, RelationsInputInvalid, RelationsStoreUnavailable, RelationTypeUnknown, SubgraphInput, RelationsOperations, RelationsPermissions, } from "./contract.js";

package/dist/relation/bind-relations.d.ts

@@ -0,0 +1,3 @@
+import { type Binding } from "@house-rules/application";
+import type { makeRelations } from "./relations.js";
+export declare const bindRelations: (service: ReturnType<typeof makeRelations>) => readonly Binding[];

package/dist/relation/bind-relations.js

@@ -0,0 +1,8 @@
+import { bindOperation } from "@house-rules/application";
+import { RelationsOperations } from "./operations.js";
+export const bindRelations = (service) => [
+    bindOperation(RelationsOperations.relate, (input) => service.relate(input)),
+    bindOperation(RelationsOperations.unrelate, ({ id }) => service.unrelate(id)),
+    bindOperation(RelationsOperations.listRelations, (input) => service.listRelations(input)),
+    bindOperation(RelationsOperations.subgraph, (input) => service.subgraph(input)),
+];

package/dist/relation/events.d.ts

@@ -0,0 +1,70 @@
+import { Schema } from "effect";
+export declare const RelationEvents: {
+    readonly Related: 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;
+        }>;
+        readonly kind: Schema.Literal<"Related">;
+    }>;
+    readonly Unrelated: 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;
+        }>;
+        readonly kind: Schema.Literal<"Unrelated">;
+    }>;
+};
+export declare const RelateResult: Schema.Struct<{
+    readonly 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;
+    }>;
+    readonly events: Schema.$Array<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;
+        }>;
+        readonly kind: Schema.Literal<"Related">;
+    }>>;
+}>;
+export type RelateResult = typeof RelateResult.Type;
+export declare const UnrelateResult: Schema.Struct<{
+    readonly events: Schema.$Array<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;
+        }>;
+        readonly kind: Schema.Literal<"Unrelated">;
+    }>>;
+}>;
+export type UnrelateResult = typeof UnrelateResult.Type;

package/dist/relation/events.js

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+import { NodeRef, Relation } from "./relation.js";
+const endpoints = { type: Schema.NonEmptyString, source: NodeRef, target: NodeRef };
+export const RelationEvents = {
+    Related: Schema.Struct({ kind: Schema.Literal("Related"), ...endpoints }),
+    Unrelated: Schema.Struct({ kind: Schema.Literal("Unrelated"), ...endpoints }),
+};
+export const RelateResult = Schema.Struct({
+    relation: Relation,
+    events: Schema.Array(RelationEvents.Related),
+});
+export const UnrelateResult = Schema.Struct({ events: Schema.Array(RelationEvents.Unrelated) });

package/dist/relation/graph.d.ts

@@ -0,0 +1,8 @@
+import type { NodeRef, Relation, RelationDirection } from "./relation.js";
+export declare const nodeKey: (node: NodeRef) => string;
+export declare const sameNode: (a: NodeRef, b: NodeRef) => boolean;
+export declare const compareNodes: (a: NodeRef, b: NodeRef) => number;
+export declare const touches: (edge: Relation, node: NodeRef, direction: RelationDirection) => boolean;
+export declare const neighbours: (edge: Relation, node: NodeRef, direction: RelationDirection) => ReadonlyArray<NodeRef>;
+export declare const copyRelation: (edge: Relation) => Relation;
+export declare const compareRelations: (a: Relation, b: Relation) => number;

package/dist/relation/graph.js

@@ -0,0 +1,15 @@
+export const nodeKey = (node) => JSON.stringify([node.kind, node.id]);
+export const sameNode = (a, b) => a.kind === b.kind && a.id === b.id;
+export const compareNodes = (a, b) => a.kind < b.kind ? -1 : a.kind > b.kind ? 1 : a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+export const touches = (edge, node, direction) => (direction !== "in" && sameNode(edge.source, node)) ||
+    (direction !== "out" && sameNode(edge.target, node));
+export const neighbours = (edge, node, direction) => [
+    ...(direction !== "in" && sameNode(edge.source, node) ? [edge.target] : []),
+    ...(direction !== "out" && sameNode(edge.target, node) ? [edge.source] : []),
+];
+export const copyRelation = (edge) => ({
+    ...edge,
+    source: { ...edge.source },
+    target: { ...edge.target },
+});
+export const compareRelations = (a, b) => a.createdAt - b.createdAt || (a.id < b.id ? -1 : a.id === b.id ? 0 : 1);

package/dist/relation/operations.d.ts

@@ -0,0 +1,117 @@
+import { Schema } from "effect";
+import { DuplicateRelation, GraphTooLarge, RelationCardinalityExceeded, RelationCycle, RelationEndpointInvalid, RelationNotFound, RelationsInputInvalid, RelationsStoreUnavailable, RelationTypeUnknown } from "./relation.js";
+export declare const RelationsOperations: {
+    readonly relate: import("@house-rules/domain/contract").Operation<"Relations.relate", 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;
+        }>;
+    }>, Schema.Struct<{
+        readonly 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;
+        }>;
+        readonly events: Schema.$Array<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;
+            }>;
+            readonly kind: Schema.Literal<"Related">;
+        }>>;
+    }>, Schema.Union<readonly [typeof RelationTypeUnknown, typeof RelationEndpointInvalid, typeof DuplicateRelation, typeof RelationCardinalityExceeded, typeof RelationCycle, typeof GraphTooLarge, typeof RelationsStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly unrelate: import("@house-rules/domain/contract").Operation<"Relations.unrelate", Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly events: Schema.$Array<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;
+            }>;
+            readonly kind: Schema.Literal<"Unrelated">;
+        }>>;
+    }>, Schema.Union<readonly [typeof RelationNotFound, typeof RelationsStoreUnavailable]>, NoInfer<readonly []>, false, true, true, false>;
+    readonly listRelations: import("@house-rules/domain/contract").Operation<"Relations.listRelations", 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;
+            }>>;
+        }>>;
+    }>, 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;
+        }>>;
+    }>, Schema.Union<readonly [typeof RelationTypeUnknown, typeof RelationEndpointInvalid, typeof RelationsInputInvalid, typeof RelationsStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly subgraph: import("@house-rules/domain/contract").Operation<"Relations.subgraph", 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>;
+    }>, 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;
+        }>>;
+    }>, Schema.Union<readonly [Schema.Union<readonly [typeof RelationTypeUnknown, typeof RelationEndpointInvalid, typeof RelationsInputInvalid, typeof RelationsStoreUnavailable]>, typeof GraphTooLarge]>, NoInfer<readonly []>, true, false, false, false>;
+};

package/dist/relation/operations.js

@@ -0,0 +1,53 @@
+import { defineOperation } from "@house-rules/domain/contract";
+import { Schema } from "effect";
+import { RelateResult, UnrelateResult } from "./events.js";
+import { RelationsPermissions } from "./permissions.js";
+import { DuplicateRelation, GraphTooLarge, ListRelationsInput, RelateInput, RelationCardinalityExceeded, RelationCycle, RelationEndpointInvalid, RelationList, RelationNotFound, RelationGraph, RelationsInputInvalid, RelationsStoreUnavailable, RelationTypeUnknown, SubgraphInput, } from "./relation.js";
+const readFailure = Schema.Union([
+    RelationTypeUnknown,
+    RelationEndpointInvalid,
+    RelationsInputInvalid,
+    RelationsStoreUnavailable,
+]);
+const relate = defineOperation("Relations.relate", {
+    description: "Connect two opaque nodes after structural validation. The app checks access and existence first.",
+    input: RelateInput,
+    output: RelateResult,
+    failure: Schema.Union([
+        RelationTypeUnknown,
+        RelationEndpointInvalid,
+        DuplicateRelation,
+        RelationCardinalityExceeded,
+        RelationCycle,
+        GraphTooLarge,
+        RelationsStoreUnavailable,
+    ]),
+    permission: RelationsPermissions.write,
+    transactional: true,
+});
+const unrelate = defineOperation("Relations.unrelate", {
+    description: "Remove one structural edge by id. The app checks endpoint access first.",
+    input: Schema.Struct({ id: Schema.NonEmptyString }),
+    output: UnrelateResult,
+    failure: Schema.Union([RelationNotFound, RelationsStoreUnavailable]),
+    permission: RelationsPermissions.write,
+    transactional: true,
+    destructive: true,
+});
+const listRelations = defineOperation("Relations.listRelations", {
+    description: "Page edges touching an opaque node. Direction follows stored endpoint order.",
+    input: ListRelationsInput,
+    output: RelationList,
+    failure: readFailure,
+    permission: RelationsPermissions.read,
+    readOnly: true,
+});
+const subgraph = defineOperation("Relations.subgraph", {
+    description: "Traverse one relation type breadth first, within configured graph bounds.",
+    input: SubgraphInput,
+    output: RelationGraph,
+    failure: Schema.Union([readFailure, GraphTooLarge]),
+    permission: RelationsPermissions.read,
+    readOnly: true,
+});
+export const RelationsOperations = { relate, unrelate, listRelations, subgraph };

package/dist/relation/options.d.ts

@@ -0,0 +1,30 @@
+import { Schema } from "effect";
+export declare const RelationType: Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly source: Schema.$Array<Schema.NonEmptyString>;
+    readonly target: Schema.$Array<Schema.NonEmptyString>;
+    readonly directed: Schema.Boolean;
+    readonly acyclic: Schema.Boolean;
+    readonly unique: Schema.Boolean;
+    readonly maxOutPerSource: Schema.optionalKey<Schema.Int>;
+    readonly maxInPerTarget: Schema.optionalKey<Schema.Int>;
+    readonly maxDegree: Schema.optionalKey<Schema.Int>;
+}>;
+export type RelationType = typeof RelationType.Type;
+export declare const RelationsOptions: Schema.Struct<{
+    readonly nodeKinds: Schema.$Array<Schema.NonEmptyString>;
+    readonly relationTypes: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly source: Schema.$Array<Schema.NonEmptyString>;
+        readonly target: Schema.$Array<Schema.NonEmptyString>;
+        readonly directed: Schema.Boolean;
+        readonly acyclic: Schema.Boolean;
+        readonly unique: Schema.Boolean;
+        readonly maxOutPerSource: Schema.optionalKey<Schema.Int>;
+        readonly maxInPerTarget: Schema.optionalKey<Schema.Int>;
+        readonly maxDegree: Schema.optionalKey<Schema.Int>;
+    }>>;
+    readonly maxGraphSize: Schema.Int;
+    readonly maxPageSize: Schema.Int;
+}>;
+export type RelationsOptions = typeof RelationsOptions.Type;

package/dist/relation/options.js

@@ -0,0 +1,27 @@
+import { Schema } from "effect";
+const cap = Schema.Int.check(Schema.isGreaterThan(0));
+export const RelationType = Schema.Struct({
+    name: Schema.NonEmptyString,
+    source: Schema.Array(Schema.NonEmptyString).check(Schema.isMinLength(1)),
+    target: Schema.Array(Schema.NonEmptyString).check(Schema.isMinLength(1)),
+    directed: Schema.Boolean,
+    acyclic: Schema.Boolean,
+    unique: Schema.Boolean,
+    maxOutPerSource: Schema.optionalKey(cap),
+    maxInPerTarget: Schema.optionalKey(cap),
+    maxDegree: Schema.optionalKey(cap),
+});
+export const RelationsOptions = Schema.Struct({
+    nodeKinds: Schema.Array(Schema.NonEmptyString).check(Schema.isMinLength(1)),
+    relationTypes: Schema.Array(RelationType),
+    maxGraphSize: cap,
+    maxPageSize: cap,
+}).check(Schema.makeFilter((options) => new Set(options.nodeKinds).size === options.nodeKinds.length &&
+    new Set(options.relationTypes.map((type) => type.name)).size ===
+        options.relationTypes.length &&
+    options.relationTypes.every((type) => [...type.source, ...type.target].every((kind) => options.nodeKinds.includes(kind)) &&
+        (type.directed
+            ? type.maxDegree === undefined
+            : !type.acyclic &&
+                type.maxOutPerSource === undefined &&
+                type.maxInPerTarget === undefined))));

package/dist/relation/permissions.d.ts

@@ -0,0 +1,5 @@
+export declare const RelationsPermissions: {
+    readonly read: "relations:read";
+    readonly write: "relations:write";
+};
+export type RelationsPermission = (typeof RelationsPermissions)[keyof typeof RelationsPermissions];

package/dist/relation/permissions.js

@@ -0,0 +1 @@
+export const RelationsPermissions = { read: "relations:read", write: "relations:write" };