@house-rules/party 0.0.0-stage → 0.1.0

package/dist/role/people.js

@@ -0,0 +1,57 @@
+import { Effect } from "effect";
+import { PartyDenied, PartyNotFound } from "../organisation/organisation.js";
+export const makePeople = (store, persons, role, adminScopes, organisationExists) => {
+    const assignmentDetails = Effect.fn("Party.assignmentDetails")(function* (personId, scopes) {
+        return yield* Effect.forEach(yield* store.scopedAssignments(personId, scopes), Effect.fnUntraced(function* (a) {
+            const held = yield* role(a.roleKey);
+            const org = a.organisationId === null ? undefined : yield* store.organisation(a.organisationId);
+            return {
+                roleKey: a.roleKey,
+                roleName: held?.name ?? a.roleKey,
+                organisationId: a.organisationId,
+                organisationName: org?.name ?? null,
+            };
+        }));
+    });
+    return {
+        listPeople: Effect.fn("Party.listPeople")(function* (caller) {
+            const scopes = yield* adminScopes(caller);
+            return yield* Effect.forEach(yield* persons.list(scopes === null ? null : yield* store.memberIds(scopes)), Effect.fnUntraced(function* (person) {
+                return {
+                    ...person,
+                    assignments: yield* assignmentDetails(person.id, scopes),
+                    organisations: yield* store.relationsFor(person.id, scopes),
+                };
+            }));
+        }),
+        listMembers: Effect.fn("Party.listMembers")(function* (caller, organisationId) {
+            const scopes = yield* adminScopes(caller).pipe(Effect.catchTag("PartyDenied", () => new PartyNotFound()));
+            if (scopes !== null && !scopes.includes(organisationId))
+                return yield* new PartyNotFound();
+            yield* organisationExists(organisationId);
+            return yield* Effect.forEach(yield* persons.list(yield* store.memberIds([organisationId])), Effect.fnUntraced(function* (person) {
+                const relations = yield* store.relationsFor(person.id, [organisationId]);
+                return {
+                    ...person,
+                    relation: relations[0]?.relation ?? null,
+                    roles: (yield* assignmentDetails(person.id, [organisationId])).map(({ roleKey, roleName }) => ({ roleKey, roleName })),
+                };
+            }));
+        }),
+        myOrganisations: Effect.fn("Party.myOrganisations")(function* (caller) {
+            if (caller.kind !== "person")
+                return yield* new PartyDenied();
+            return yield* Effect.forEach(yield* store.organisationsFor(caller.actor.id), Effect.fnUntraced(function* (org) {
+                const roles = yield* Effect.forEach(yield* store.scopedAssignments(caller.actor.id, [org.id]), Effect.fnUntraced(function* (a) {
+                    const held = yield* role(a.roleKey);
+                    return {
+                        roleKey: a.roleKey,
+                        roleName: held?.name ?? a.roleKey,
+                        permissions: held?.permissions ?? [],
+                    };
+                }));
+                return { ...org, roles };
+            }));
+        }),
+    };
+};

package/dist/role/permission-catalogue.d.ts

@@ -0,0 +1,2 @@
+import type { PermissionCatalogue } from "@house-rules/application";
+export type RoleCatalogue = PermissionCatalogue["Service"];

package/dist/role/permission-catalogue.js

@@ -0,0 +1 @@
+export {};

package/dist/role/role.d.ts

@@ -0,0 +1,31 @@
+import { Effect, Schema } from "effect";
+import { PartyInputInvalid } from "../organisation/organisation.js";
+export declare const RoleKey: Schema.NonEmptyString;
+export declare const RolePermission: Schema.String;
+export declare const Role: 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;
+}>;
+export type Role = typeof Role.Type;
+export type BuiltInRoles = Readonly<Record<string, {
+    readonly name: string;
+    readonly permissions: readonly string[];
+}>>;
+export interface PartyOptions {
+    readonly builtInRoles: BuiltInRoles;
+    readonly holdersLimit?: number;
+    readonly handles?: {
+        readonly pattern?: RegExp;
+        readonly reserved?: readonly string[];
+    };
+}
+export declare const validateRole: (input: Role) => Effect.Effect<{
+    readonly key: string;
+    readonly name: string;
+    readonly permissions: readonly string[];
+    readonly organisationId: string | null;
+    readonly builtIn: boolean;
+}, PartyInputInvalid, never>;

package/dist/role/role.js

@@ -0,0 +1,12 @@
+import { Effect, Schema } from "effect";
+import { PartyInputInvalid } from "../organisation/organisation.js";
+export const RoleKey = Schema.NonEmptyString;
+export const RolePermission = Schema.String.check(Schema.isPattern(/^[a-z][a-z0-9_-]*:[a-z][a-z0-9_-]*$/u));
+export const Role = Schema.Struct({
+    key: RoleKey,
+    name: Schema.NonEmptyString,
+    permissions: Schema.Array(RolePermission),
+    organisationId: Schema.NullOr(Schema.NonEmptyString),
+    builtIn: Schema.Boolean,
+});
+export const validateRole = (input) => Schema.decodeEffect(Role)(input).pipe(Effect.mapError(() => new PartyInputInvalid({ message: "Invalid role or permission." })));

package/dist/storage.d.ts

@@ -0,0 +1,38 @@
+import type { ActorId, NoOpenUnit } from "@house-rules/domain";
+import { Context, type Effect } from "effect";
+import type { Assignment } from "./assignment/assignment.js";
+import type { Organisation, OrganisationRelation, OwnOrganisation, PartyUnavailable } from "./organisation/organisation.js";
+import type { Relationship } from "./relationship/relationship.js";
+import type { Role } from "./role/role.js";
+import type { StoredInvitation } from "./invitation/invitation.js";
+export { PersonStore } from "./person/person-store.js";
+type Read<A> = Effect.Effect<A, PartyUnavailable>;
+type Write<A> = Effect.Effect<A, PartyUnavailable | NoOpenUnit>;
+declare const PartyStore_base: Context.ServiceClass<PartyStore, "@house-rules/party/PartyStore", {
+    readonly organisation: (id: string) => Read<Organisation | undefined>;
+    readonly organisationsFor: (personId: ActorId) => Read<readonly OwnOrganisation[]>;
+    readonly relationsFor: (personId: ActorId, organisationIds: readonly string[] | null) => Read<readonly OrganisationRelation[]>;
+    readonly scopedAssignments: (personId: ActorId, organisationIds: readonly string[] | null) => Read<readonly Assignment[]>;
+    readonly assignmentsInOrganisation: (organisationId: string) => Read<readonly Assignment[]>;
+    readonly holderIds: (role: string, scope: string | null, take: number) => Read<readonly ActorId[]>;
+    readonly lockOrganisation: (organisationId: string) => Write<void>;
+    readonly memberIds: (organisationIds: readonly string[]) => Read<readonly ActorId[]>;
+    readonly insertInvitation: (value: StoredInvitation) => Write<void>;
+    readonly consumeInvitation: (hash: string, now: number) => Write<StoredInvitation | undefined>;
+    readonly invitation: (id: string) => Read<StoredInvitation | undefined>;
+    readonly invitations: (organisationId: string) => Read<readonly StoredInvitation[]>;
+    readonly revokeInvitation: (id: string) => Write<void>;
+    readonly insertOrganisation: (organisation: Organisation) => Write<boolean>;
+    readonly relate: (relationship: Relationship) => Write<void>;
+    readonly unrelate: (relationship: Relationship) => Write<void>;
+    readonly isRelated: (relationship: Relationship) => Read<boolean>;
+    readonly role: (key: string) => Read<Role | undefined>;
+    readonly roles: (organisationIds?: readonly string[] | null) => Read<readonly Role[]>;
+    readonly putRole: (role: Role) => Write<void>;
+    readonly deleteRole: (key: string) => Write<void>;
+    readonly assign: (assignment: Assignment) => Write<void>;
+    readonly revoke: (assignment: Assignment) => Write<void>;
+    readonly assignments: (personId: ActorId, organisationIds?: readonly string[] | null, builtInKeys?: readonly string[]) => Read<readonly Assignment[]>;
+}>;
+export declare class PartyStore extends PartyStore_base {
+}

package/dist/storage.js

@@ -0,0 +1,4 @@
+import { Context } from "effect";
+export { PersonStore } from "./person/person-store.js";
+export class PartyStore extends Context.Service()("@house-rules/party/PartyStore") {
+}

package/migrations/0001_party_person.sql

@@ -0,0 +1,5 @@
+create table party_person (
+  id text primary key,
+  display_name text not null,
+  created_at timestamptz not null default now()
+);

package/migrations/0002_party_model.sql

@@ -0,0 +1,27 @@
+CREATE TABLE party_organisation (
+  id text PRIMARY KEY,
+  name text NOT NULL CHECK (length(name) > 0)
+);
+--> statement-breakpoint
+CREATE TABLE party_relationship (
+  from_kind text NOT NULL CHECK (from_kind IN ('person', 'organisation')),
+  from_id text NOT NULL,
+  to_kind text NOT NULL CHECK (to_kind IN ('person', 'organisation')),
+  to_id text NOT NULL,
+  kind text NOT NULL CHECK (length(kind) > 0),
+  PRIMARY KEY (from_kind, from_id, to_kind, to_id, kind)
+);
+--> statement-breakpoint
+CREATE TABLE party_role (
+  key text PRIMARY KEY,
+  name text NOT NULL CHECK (length(name) > 0),
+  permissions text[] NOT NULL,
+  organisation_id text REFERENCES party_organisation(id)
+);
+--> statement-breakpoint
+CREATE TABLE party_assignment (
+  person_id text NOT NULL REFERENCES party_person(id) ON DELETE CASCADE,
+  role_key text NOT NULL,
+  organisation_id text REFERENCES party_organisation(id),
+  UNIQUE NULLS NOT DISTINCT (person_id, role_key, organisation_id)
+);

package/migrations/0003_party_invitation.sql

@@ -0,0 +1,11 @@
+CREATE TABLE party_invitation (
+  id text PRIMARY KEY,
+  organisation_id text NOT NULL,
+  role_key text,
+  created_by text NOT NULL,
+  code_hash text NOT NULL UNIQUE,
+  expires_at double precision NOT NULL,
+  state text NOT NULL CHECK (state IN ('pending', 'used', 'revoked'))
+);
+--> statement-breakpoint
+CREATE INDEX party_invitation_org ON party_invitation (organisation_id);

package/migrations/0004_publish_staff.sql

@@ -0,0 +1,4 @@
+CREATE VIEW party_staff_read AS
+SELECT from_id AS person_id, to_id AS organisation_id
+FROM party_relationship
+WHERE from_kind = 'person' AND to_kind = 'organisation' AND kind = 'staff';

package/migrations/0005_principals.sql

@@ -0,0 +1,18 @@
+alter table party_person
+  add column kind text not null default 'person' check (kind in ('person', 'agent')),
+  add column handle text,
+  add column created_by text,
+  add column disabled_at timestamptz;
+--> statement-breakpoint
+update party_person set handle = id;
+--> statement-breakpoint
+alter table party_person alter column handle set not null;
+--> statement-breakpoint
+alter table party_person add constraint party_person_handle_unique unique (handle);
+--> statement-breakpoint
+create view party_principals_read as
+select id, display_name, kind, handle, created_by, created_at, disabled_at
+from party_person;
+--> statement-breakpoint
+create view party_assignments_read as
+select person_id, role_key, organisation_id from party_assignment;

package/package.json

@@ -1,6 +1,60 @@
 {
   "name": "@house-rules/party",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Person records keyed by ActorId, with self-only rename and module-owned storage.",
+  "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"
+  },
+  "houseRules": {
+    "migrations": "migrations"
+  },
+  "peerDependencies": {
+    "@house-rules/application": "0.2.0",
+    "@house-rules/domain": "0.2.0",
+    "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.2.0",
+    "@house-rules/domain": "0.2.0",
+    "@house-rules/migrations": "0.4.0",
+    "effect": "4.0.3",
+    "typescript": "7.0.2",
+    "vitest": "5.0.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JakubSzwajka/house-rules.git",
+    "directory": "packages/party"
+  },
+  "bugs": {
+    "url": "https://github.com/JakubSzwajka/house-rules/issues"
+  },
+  "homepage": "https://github.com/JakubSzwajka/house-rules",
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "typecheck": "tsc --project tsconfig.json",
+    "test": "varlock run --path ../../ -- vitest run"
+  }
 }