@house-rules/party 0.0.0-stage → 0.1.0

package/dist/role/access.js

@@ -0,0 +1,252 @@
+import { UnitOfWork, } from "@house-rules/domain";
+import { Effect } from "effect";
+import { makePeople } from "./people.js";
+import { makeHolders } from "../assignment/holders.js";
+import { makeInvitations } from "../invitation/invitations.js";
+import { validateAssignment } from "../assignment/assignment.js";
+import { PartyConflict, PartyDenied, PartyInputInvalid, PartyNotFound, PartyUnavailable, validateOrganisation, } from "../organisation/organisation.js";
+import { validateRelationship, } from "../relationship/relationship.js";
+import { removeStaffAssignments } from "../relationship/removal.js";
+import { validateRole } from "./role.js";
+export const makeAccess = (store, persons, options, catalogue) => {
+    const builtIns = Object.entries(options.builtInRoles).map(([key, role]) => ({
+        key,
+        name: role.name,
+        permissions: [...role.permissions],
+        builtIn: true,
+        organisationId: null,
+    }));
+    const role = (key) => {
+        const builtIn = builtIns.find((r) => r.key === key);
+        return builtIn ? Effect.succeed(builtIn) : store.role(key);
+    };
+    const permissionsOf = Effect.fn("Party.permissionsOf")(function* (caller) {
+        const principal = yield* persons.principal(caller.actor.id);
+        if (principal && principal.disabledAt !== null)
+            return [];
+        const allowed = catalogue ? new Set(yield* catalogue.permissions()) : undefined;
+        const permissions = new Set();
+        for (const assignment of yield* store.assignments(caller.actor.id)) {
+            const held = yield* role(assignment.roleKey);
+            if (!held ||
+                (held.organisationId !== null && held.organisationId !== assignment.organisationId))
+                continue;
+            for (const p of held.permissions)
+                if (!allowed || allowed.has(p))
+                    permissions.add(p);
+        }
+        return [...permissions].sort();
+    });
+    const admin = Effect.fn("Party.admin")(function* (caller, organisationId) {
+        if (caller.kind !== "person")
+            return yield* new PartyDenied();
+        const allowed = catalogue ? new Set(yield* catalogue.permissions()) : undefined;
+        if (allowed && !allowed.has("party:admin"))
+            return yield* new PartyDenied();
+        for (const assignment of yield* store.assignments(caller.actor.id)) {
+            const held = yield* role(assignment.roleKey);
+            if (held &&
+                (held.organisationId === null || held.organisationId === assignment.organisationId) &&
+                held.permissions.includes("party:admin") &&
+                (assignment.organisationId === null || assignment.organisationId === organisationId))
+                return;
+        }
+        return yield* new PartyDenied();
+    });
+    const mayDelegate = Effect.fn("Party.mayDelegate")(function* (caller, permissions, organisationId) {
+        if (caller.kind === "system")
+            return;
+        const held = new Set();
+        for (const assignment of yield* store.assignments(caller.actor.id)) {
+            if (assignment.organisationId !== null && assignment.organisationId !== organisationId)
+                continue;
+            const assigned = yield* role(assignment.roleKey);
+            if (assigned &&
+                (assigned.organisationId === null || assigned.organisationId === assignment.organisationId))
+                for (const permission of assigned.permissions)
+                    held.add(permission);
+        }
+        if (permissions.some((permission) => !held.has(permission)))
+            return yield* new PartyDenied();
+    });
+    const visibleScopes = Effect.fn("Party.visibleScopes")(function* (caller) {
+        if (caller.kind === "system")
+            return null;
+        const scopes = new Set();
+        for (const assignment of yield* store.assignments(caller.actor.id)) {
+            const held = yield* role(assignment.roleKey);
+            if (!held ||
+                (held.organisationId !== null && held.organisationId !== assignment.organisationId))
+                continue;
+            if (assignment.organisationId === null) {
+                if (held.permissions.includes("party:admin"))
+                    return null;
+            }
+            else
+                scopes.add(assignment.organisationId);
+        }
+        return [...scopes];
+    });
+    const organisationExists = Effect.fn("Party.organisationExists")(function* (id) {
+        if (id !== null && !(yield* store.organisation(id)))
+            return yield* new PartyNotFound();
+    });
+    const partyExists = Effect.fn("Party.partyExists")(function* (ref) {
+        const found = ref.kind === "person"
+            ? yield* persons.find(ref.id)
+            : yield* store.organisation(ref.id);
+        if (!found)
+            return yield* new PartyNotFound();
+    });
+    const relationScope = Effect.fn("Party.relationScope")(function* (caller, r) {
+        // A scoped admin must control every organisation in a relation, not merely one endpoint.
+        const organisations = [r.from, r.to].filter((p) => p.kind === "organisation");
+        if (organisations.length === 0)
+            yield* admin(caller, null);
+        for (const org of organisations)
+            yield* admin(caller, org.id);
+    });
+    const adminScopes = Effect.fn("Party.adminScopes")(function* (caller) {
+        if (caller.kind !== "person")
+            return yield* new PartyDenied();
+        const scopes = new Set();
+        if (catalogue && !(yield* catalogue.permissions()).includes("party:admin"))
+            return yield* new PartyDenied();
+        for (const assignment of yield* store.assignments(caller.actor.id)) {
+            const held = yield* role(assignment.roleKey);
+            if (!held ||
+                !held.permissions.includes("party:admin") ||
+                (held.organisationId !== null && held.organisationId !== assignment.organisationId))
+                continue;
+            if (assignment.organisationId === null)
+                return null;
+            scopes.add(assignment.organisationId);
+        }
+        if (scopes.size === 0)
+            return yield* new PartyDenied();
+        return [...scopes];
+    });
+    const checkInvitationRole = Effect.fn("Party.checkInvitationRole")(function* (caller, key, org) {
+        yield* admin(caller, org);
+        const held = yield* role(key);
+        if (!held)
+            return yield* new PartyNotFound();
+        if (held.organisationId !== null && held.organisationId !== org)
+            return yield* new PartyDenied();
+        yield* mayDelegate(caller, held.permissions, org);
+    });
+    return {
+        ...makeInvitations(store, admin, checkInvitationRole),
+        ...makePeople(store, persons, role, adminScopes, organisationExists),
+        permissionsOf,
+        ...makeHolders(store, options.holdersLimit ?? 1000),
+        canAdminOrganisation: Effect.fn("Party.canAdminOrganisation")(function* (caller, organisationId) {
+            if (!(yield* store.organisation(organisationId)))
+                return false;
+            return yield* admin(caller, organisationId).pipe(Effect.as(true), Effect.catchTag("PartyDenied", () => Effect.succeed(false)));
+        }),
+        myAccess: Effect.fn("Party.myAccess")(function* (caller) {
+            if (caller.kind !== "person")
+                return yield* new PartyDenied();
+            return {
+                roles: yield* store.assignments(caller.actor.id),
+                permissions: yield* permissionsOf(caller),
+                catalogue: catalogue ? [...(yield* catalogue.permissions())].sort() : [],
+            };
+        }),
+        createOrganisation: Effect.fn("Party.createOrganisation")(function* (caller, input) {
+            yield* UnitOfWork.required;
+            if (caller.kind !== "person")
+                return yield* new PartyDenied();
+            const value = yield* validateOrganisation(input);
+            if (!(yield* store.insertOrganisation(value)))
+                return yield* new PartyConflict();
+            yield* store.relate({
+                from: { kind: "person", id: caller.actor.id },
+                to: { kind: "organisation", id: value.id },
+                kind: "staff",
+            });
+            return value;
+        }),
+        showOrganisation: Effect.fn("Party.showOrganisation")(function* (id) {
+            const value = yield* store.organisation(id);
+            if (!value)
+                return yield* new PartyNotFound();
+            return value;
+        }),
+        relate: Effect.fn("Party.relate")(function* (caller, input) {
+            yield* UnitOfWork.required;
+            const value = yield* validateRelationship(input);
+            yield* relationScope(caller, value);
+            yield* partyExists(value.from);
+            yield* partyExists(value.to);
+            yield* store.relate(value);
+        }),
+        unrelate: Effect.fn("Party.unrelate")(function* (caller, input) {
+            yield* UnitOfWork.required;
+            const value = yield* validateRelationship(input);
+            yield* relationScope(caller, value);
+            yield* removeStaffAssignments(store, role, value);
+            yield* store.unrelate(value);
+        }),
+        isRelated: (input) => validateRelationship(input).pipe(Effect.flatMap(store.isRelated)),
+        defineRole: Effect.fn("Party.defineRole")(function* (caller, input) {
+            yield* UnitOfWork.required;
+            const value = yield* validateRole({ ...input, builtIn: false });
+            yield* admin(caller, value.organisationId);
+            if (builtIns.some((r) => r.key === value.key))
+                return yield* new PartyConflict();
+            const previous = yield* store.role(value.key);
+            if (previous)
+                yield* admin(caller, previous.organisationId);
+            yield* organisationExists(value.organisationId);
+            if (!catalogue)
+                return yield* new PartyUnavailable({ cause: "Permission catalogue not mounted" });
+            const allowed = new Set(yield* catalogue.permissions());
+            if (value.permissions.some((p) => !allowed.has(p)))
+                return yield* new PartyInputInvalid({ message: "Unknown role permission." });
+            yield* mayDelegate(caller, value.permissions, value.organisationId);
+            yield* store.putRole(value);
+            return value;
+        }),
+        deleteRole: Effect.fn("Party.deleteRole")(function* (caller, key) {
+            yield* UnitOfWork.required;
+            const value = yield* role(key);
+            if (!value)
+                return yield* new PartyNotFound();
+            yield* admin(caller, value.organisationId);
+            if (value.builtIn)
+                return yield* new PartyConflict();
+            yield* store.deleteRole(key);
+        }),
+        listRoles: Effect.fn("Party.listRoles")(function* (caller) {
+            return [...builtIns, ...(yield* store.roles(yield* visibleScopes(caller)))];
+        }),
+        assignRole: Effect.fn("Party.assignRole")(function* (caller, input) {
+            yield* UnitOfWork.required;
+            const value = yield* validateAssignment(input);
+            // Trusted first sign-in can assign a default role without person authority.
+            if (caller.kind !== "system")
+                yield* admin(caller, value.organisationId);
+            yield* organisationExists(value.organisationId);
+            if (!(yield* persons.find(value.personId)))
+                return yield* new PartyNotFound();
+            const held = yield* role(value.roleKey);
+            if (!held)
+                return yield* new PartyNotFound();
+            if (held.organisationId !== null && held.organisationId !== value.organisationId)
+                return yield* new PartyDenied();
+            yield* mayDelegate(caller, held.permissions, value.organisationId);
+            yield* store.assign(value);
+        }),
+        revokeRole: Effect.fn("Party.revokeRole")(function* (caller, input) {
+            yield* UnitOfWork.required;
+            const value = yield* validateAssignment(input);
+            yield* admin(caller, value.organisationId);
+            yield* store.revoke(value);
+        }),
+        rolesOf: Effect.fn("Party.rolesOf")(function* (caller, personId) {
+            return yield* store.assignments(personId, yield* visibleScopes(caller), builtIns.map((r) => r.key));
+        }),
+    };
+};

package/dist/role/operations.d.ts

@@ -0,0 +1,145 @@
+import { Schema } from "effect";
+import { PartyLastAdmin, PartyConflict, PartyDenied, PartyInputInvalid, PartyNotFound, PartyUnavailable } from "../organisation/organisation.js";
+export declare const AccessOperations: {
+    readonly canAdminOrganisation: import("@house-rules/domain/contract").Operation<"Party.canAdminOrganisation", Schema.Struct<{
+        readonly organisationId: Schema.String;
+    }>, Schema.Boolean, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly createInvitation: import("@house-rules/domain/contract").Operation<"Party.createInvitation", Schema.Struct<{
+        readonly organisationId: Schema.String;
+        readonly roleKey: Schema.NullOr<Schema.String>;
+    }>, Schema.Struct<{
+        readonly invitation: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly organisationId: Schema.String;
+            readonly roleKey: Schema.NullOr<Schema.String>;
+            readonly createdBy: Schema.brand<Schema.NonEmptyString, "ActorId">;
+            readonly expiresAt: Schema.Finite;
+            readonly state: Schema.Literals<readonly ["pending", "used", "revoked"]>;
+        }>;
+        readonly code: Schema.String;
+    }>, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly acceptInvitation: import("@house-rules/domain/contract").Operation<"Party.acceptInvitation", Schema.Struct<{
+        readonly code: Schema.String;
+    }>, Schema.Struct<{
+        readonly organisationId: Schema.String;
+        readonly roleKey: Schema.NullOr<Schema.String>;
+        readonly personId: Schema.brand<Schema.NonEmptyString, "ActorId">;
+    }>, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly revokeInvitation: import("@house-rules/domain/contract").Operation<"Party.revokeInvitation", Schema.Struct<{
+        readonly id: Schema.String;
+    }>, Schema.Void, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, true, true, true>;
+    readonly listInvitations: import("@house-rules/domain/contract").Operation<"Party.listInvitations", Schema.Struct<{
+        readonly organisationId: Schema.String;
+    }>, Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly organisationId: Schema.String;
+        readonly roleKey: Schema.NullOr<Schema.String>;
+        readonly createdBy: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly expiresAt: Schema.Finite;
+        readonly state: Schema.Literals<readonly ["pending", "used", "revoked"]>;
+    }>>, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly myOrganisations: import("@house-rules/domain/contract").Operation<"Party.myOrganisations", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly name: Schema.NonEmptyString;
+        readonly relation: Schema.NullOr<Schema.String>;
+        readonly roles: Schema.$Array<Schema.Struct<{
+            readonly roleKey: Schema.String;
+            readonly roleName: Schema.String;
+            readonly permissions: Schema.$Array<Schema.String>;
+        }>>;
+    }>>, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly myAccess: import("@house-rules/domain/contract").Operation<"Party.myAccess", Schema.$Record<Schema.String, Schema.Never>, Schema.Struct<{
+        readonly roles: Schema.$Array<Schema.Struct<{
+            readonly personId: Schema.brand<Schema.NonEmptyString, "ActorId">;
+            readonly roleKey: Schema.NonEmptyString;
+            readonly organisationId: Schema.NullOr<Schema.NonEmptyString>;
+        }>>;
+        readonly permissions: Schema.$Array<Schema.String>;
+        readonly catalogue: Schema.$Array<Schema.String>;
+    }>, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly createOrganisation: import("@house-rules/domain/contract").Operation<"Party.createOrganisation", Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly name: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly name: Schema.NonEmptyString;
+    }>, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly showOrganisation: import("@house-rules/domain/contract").Operation<"Party.showOrganisation", Schema.Struct<{
+        readonly id: Schema.String;
+    }>, Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly name: Schema.NonEmptyString;
+    }>, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly relate: import("@house-rules/domain/contract").Operation<"Party.relate", Schema.Struct<{
+        readonly from: Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["person", "organisation"]>;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly to: Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["person", "organisation"]>;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly kind: Schema.NonEmptyString;
+    }>, Schema.Void, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly unrelate: import("@house-rules/domain/contract").Operation<"Party.unrelate", Schema.Struct<{
+        readonly from: Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["person", "organisation"]>;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly to: Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["person", "organisation"]>;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly kind: Schema.NonEmptyString;
+    }>, Schema.Void, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, true, true, true>;
+    readonly isRelated: import("@house-rules/domain/contract").Operation<"Party.isRelated", Schema.Struct<{
+        readonly from: Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["person", "organisation"]>;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly to: Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["person", "organisation"]>;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly kind: Schema.NonEmptyString;
+    }>, Schema.Boolean, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly defineRole: import("@house-rules/domain/contract").Operation<"Party.defineRole", Schema.Struct<{
+        readonly key: Schema.String;
+        readonly name: Schema.String;
+        readonly permissions: Schema.$Array<Schema.String>;
+        readonly organisationId: Schema.NullOr<Schema.String>;
+    }>, Schema.Struct<{
+        readonly key: Schema.NonEmptyString;
+        readonly name: Schema.NonEmptyString;
+        readonly permissions: Schema.$Array<Schema.String>;
+        readonly organisationId: Schema.NullOr<Schema.NonEmptyString>;
+        readonly builtIn: Schema.Boolean;
+    }>, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly deleteRole: import("@house-rules/domain/contract").Operation<"Party.deleteRole", Schema.Struct<{
+        readonly key: Schema.String;
+    }>, Schema.Void, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, true, true, true>;
+    readonly listRoles: import("@house-rules/domain/contract").Operation<"Party.listRoles", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
+        readonly key: Schema.NonEmptyString;
+        readonly name: Schema.NonEmptyString;
+        readonly permissions: Schema.$Array<Schema.String>;
+        readonly organisationId: Schema.NullOr<Schema.NonEmptyString>;
+        readonly builtIn: Schema.Boolean;
+    }>>, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly assignRole: import("@house-rules/domain/contract").Operation<"Party.assignRole", Schema.Struct<{
+        readonly personId: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly roleKey: Schema.NonEmptyString;
+        readonly organisationId: Schema.NullOr<Schema.NonEmptyString>;
+    }>, Schema.Void, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly revokeRole: import("@house-rules/domain/contract").Operation<"Party.revokeRole", Schema.Struct<{
+        readonly personId: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly roleKey: Schema.NonEmptyString;
+        readonly organisationId: Schema.NullOr<Schema.NonEmptyString>;
+    }>, Schema.Void, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, true, true, true>;
+    readonly rolesOf: import("@house-rules/domain/contract").Operation<"Party.rolesOf", Schema.Struct<{
+        readonly personId: Schema.brand<Schema.NonEmptyString, "ActorId">;
+    }>, Schema.$Array<Schema.Struct<{
+        readonly personId: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly roleKey: Schema.NonEmptyString;
+        readonly organisationId: Schema.NullOr<Schema.NonEmptyString>;
+    }>>, Schema.Union<readonly [typeof PartyLastAdmin, typeof PartyConflict, typeof PartyDenied, typeof PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+};

package/dist/role/operations.js

@@ -0,0 +1,215 @@
+import { ActorId, defineOperation, NoInput } from "@house-rules/domain/contract";
+import { Schema } from "effect";
+import { Assignment } from "../assignment/assignment.js";
+import { Organisation, OwnOrganisation, PartyLastAdmin, PartyConflict, PartyDenied, PartyInputInvalid, PartyNotFound, PartyUnavailable, } from "../organisation/organisation.js";
+import { Relationship } from "../relationship/relationship.js";
+import { Role } from "./role.js";
+import { CreatedInvitation, Invitation, InvitationAcceptance } from "../invitation/invitation.js";
+const failure = Schema.Union([
+    PartyLastAdmin,
+    PartyConflict,
+    PartyDenied,
+    PartyInputInvalid,
+    PartyNotFound,
+    PartyUnavailable,
+]);
+const createOrganisation = defineOperation("Party.createOrganisation", {
+    description: "Create an organisation.",
+    input: Organisation,
+    output: Organisation,
+    failure,
+    permission: "party:create-organisation",
+    edges: [],
+    transactional: true,
+});
+const showOrganisation = defineOperation("Party.showOrganisation", {
+    description: "Show an organisation.",
+    input: Schema.Struct({ id: Schema.String }),
+    output: Organisation,
+    failure,
+    permission: "party:read",
+    edges: [],
+    readOnly: true,
+});
+const relate = defineOperation("Party.relate", {
+    description: "Relate two parties.",
+    input: Relationship,
+    output: Schema.Void,
+    failure,
+    permission: "party:admin",
+    edges: [],
+    transactional: true,
+});
+const unrelate = defineOperation("Party.unrelate", {
+    description: "Remove a relationship.",
+    input: Relationship,
+    output: Schema.Void,
+    failure,
+    permission: "party:admin",
+    edges: [],
+    transactional: true,
+    destructive: true,
+    needsApproval: true,
+});
+const isRelated = defineOperation("Party.isRelated", {
+    description: "Check a relationship between parties.",
+    input: Relationship,
+    output: Schema.Boolean,
+    failure,
+    permission: "party:read",
+    edges: [],
+    readOnly: true,
+});
+const canAdminOrganisation = defineOperation("Party.canAdminOrganisation", {
+    description: "Check your current admin permission in an organisation scope.",
+    input: Schema.Struct({ organisationId: Schema.String }),
+    output: Schema.Boolean,
+    failure,
+    permission: "party:read",
+    readOnly: true,
+});
+const defineRole = defineOperation("Party.defineRole", {
+    description: "Create or update a custom role.",
+    input: Schema.Struct({
+        key: Schema.String,
+        name: Schema.String,
+        permissions: Schema.Array(Schema.String),
+        organisationId: Schema.NullOr(Schema.String),
+    }),
+    output: Role,
+    failure,
+    permission: "party:admin",
+    edges: [],
+    transactional: true,
+});
+const deleteRole = defineOperation("Party.deleteRole", {
+    description: "Delete a custom role and its assignments.",
+    input: Schema.Struct({ key: Schema.String }),
+    output: Schema.Void,
+    failure,
+    permission: "party:admin",
+    edges: [],
+    transactional: true,
+    destructive: true,
+    needsApproval: true,
+});
+const listRoles = defineOperation("Party.listRoles", {
+    description: "List built-in and custom roles.",
+    input: NoInput,
+    output: Schema.Array(Role),
+    failure,
+    permission: "party:read",
+    edges: [],
+    readOnly: true,
+});
+const assignRole = defineOperation("Party.assignRole", {
+    description: "Assign a role as an administrator or trusted system setup.",
+    input: Assignment,
+    output: Schema.Void,
+    failure,
+    permission: "party:admin",
+    edges: [],
+    transactional: true,
+});
+const revokeRole = defineOperation("Party.revokeRole", {
+    description: "Revoke a role assignment.",
+    input: Assignment,
+    output: Schema.Void,
+    failure,
+    permission: "party:admin",
+    edges: [],
+    transactional: true,
+    destructive: true,
+    needsApproval: true,
+});
+const rolesOf = defineOperation("Party.rolesOf", {
+    description: "Read a person's role assignments.",
+    input: Schema.Struct({ personId: ActorId }),
+    output: Schema.Array(Assignment),
+    failure,
+    permission: "party:read",
+    edges: [],
+    readOnly: true,
+});
+const myAccess = defineOperation("Party.myAccess", {
+    description: "Read your own role assignments, effective permissions and the app catalogue.",
+    input: NoInput,
+    output: Schema.Struct({
+        roles: Schema.Array(Assignment),
+        permissions: Schema.Array(Schema.String),
+        catalogue: Schema.Array(Schema.String),
+    }),
+    failure,
+    permission: "party:read",
+    edges: [],
+    readOnly: true,
+});
+const createInvitation = defineOperation("Party.createInvitation", {
+    description: "Invite a person into your organisation with an optional delegated role.",
+    input: Schema.Struct({ organisationId: Schema.String, roleKey: Schema.NullOr(Schema.String) }),
+    output: CreatedInvitation,
+    failure,
+    permission: "party:admin",
+    transactional: true,
+});
+const acceptInvitation = defineOperation("Party.acceptInvitation", {
+    description: "Consume a one-time invitation and join as staff.",
+    input: Schema.Struct({ code: Schema.String }),
+    output: InvitationAcceptance,
+    failure,
+    permission: "party:read",
+    transactional: true,
+});
+const revokeInvitation = defineOperation("Party.revokeInvitation", {
+    description: "Revoke an invitation in your organisation.",
+    input: Schema.Struct({ id: Schema.String }),
+    output: Schema.Void,
+    failure,
+    permission: "party:admin",
+    transactional: true,
+    destructive: true,
+    needsApproval: true,
+});
+const listInvitations = defineOperation("Party.listInvitations", {
+    description: "List invitations in an organisation you administer, without codes or hashes.",
+    input: Schema.Struct({ organisationId: Schema.String }),
+    output: Schema.Array(Invitation),
+    failure,
+    permission: "party:admin",
+    readOnly: true,
+});
+const myOrganisations = defineOperation("Party.myOrganisations", {
+    description: "List organisations you belong to.",
+    input: NoInput,
+    output: Schema.Array(Schema.Struct({
+        ...OwnOrganisation.fields,
+        roles: Schema.Array(Schema.Struct({
+            roleKey: Schema.String,
+            roleName: Schema.String,
+            permissions: Schema.Array(Schema.String),
+        })),
+    })),
+    failure,
+    permission: "party:read",
+    readOnly: true,
+});
+export const AccessOperations = {
+    canAdminOrganisation,
+    createInvitation,
+    acceptInvitation,
+    revokeInvitation,
+    listInvitations,
+    myOrganisations,
+    myAccess,
+    createOrganisation,
+    showOrganisation,
+    relate,
+    unrelate,
+    isRelated,
+    defineRole,
+    deleteRole,
+    listRoles,
+    assignRole,
+    revokeRole,
+    rolesOf,
+};

package/dist/role/people.d.ts

@@ -0,0 +1,45 @@
+import type { ActorId, Caller } from "@house-rules/domain";
+import { Effect } from "effect";
+import { PartyDenied, PartyNotFound, type PartyUnavailable } from "../organisation/organisation.js";
+import type { PartyStore, PersonStore } from "../storage.js";
+import type { Role } from "./role.js";
+export declare const makePeople: (store: PartyStore["Service"], persons: {
+    readonly list: (ids: readonly ActorId[] | null) => Effect.Effect<Effect.Success<ReturnType<PersonStore["Service"]["list"]>>, PartyUnavailable>;
+}, role: (key: string) => Effect.Effect<Role | undefined, PartyUnavailable>, adminScopes: (caller: Caller) => Effect.Effect<string[] | null, PartyDenied | PartyUnavailable>, organisationExists: (id: string | null) => Effect.Effect<void, PartyNotFound | PartyUnavailable>) => {
+    listPeople: (caller: Caller) => Effect.Effect<{
+        id: string & import("effect/Brand").Brand<"ActorId">;
+        displayName: string;
+        createdAt: number;
+        assignments: {
+            roleKey: string;
+            roleName: string;
+            organisationId: string | null;
+            organisationName: string | null;
+        }[];
+        organisations: readonly {
+            readonly id: string;
+            readonly name: string;
+            readonly relation: string;
+        }[];
+    }[], PartyDenied | PartyUnavailable, never>;
+    listMembers: (caller: Caller, organisationId: string) => Effect.Effect<{
+        id: string & import("effect/Brand").Brand<"ActorId">;
+        displayName: string;
+        createdAt: number;
+        relation: string | null;
+        roles: {
+            roleKey: string;
+            roleName: string;
+        }[];
+    }[], PartyNotFound | PartyUnavailable, never>;
+    myOrganisations: (caller: Caller) => Effect.Effect<{
+        id: string;
+        name: string;
+        relation: string | null;
+        roles: {
+            roleKey: string;
+            roleName: string;
+            permissions: readonly string[];
+        }[];
+    }[], PartyDenied | PartyUnavailable, never>;
+};