@lenso/organization 0.0.0-stage → 0.2.0

package/dist/index-2bwbvaz5.js

@@ -0,0 +1,67 @@
+import {
+  assertSnapshotCapacity
+} from "./index-qgnmjsxx.js";
+
+// src/drizzle/shared.ts
+function assertValidVersion(value, label) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`Invalid organization ${label}`);
+  }
+}
+function validateState(state) {
+  if (!state || typeof state !== "object" || !state.organization || !validText(state.organization.id, 256) || !validText(state.organization.name, 200) || !validTime(state.organization.createdAt) || !validTime(state.organization.updatedAt)) {
+    throw new Error("Invalid persisted organization state");
+  }
+  assertValidVersion(state.organization.version, "state version");
+  if (!Array.isArray(state.members) || !Array.isArray(state.invitations) || state.members.length > 1000 || state.invitations.length > 1000 || !state.members.some((member) => member?.role === "owner")) {
+    throw new Error("Invalid persisted organization state");
+  }
+  const subjects = new Set;
+  for (const member of state.members) {
+    if (!member || !validSubject(member.subject) || !["member", "admin", "owner"].includes(member.role) || !validTime(member.joinedAt))
+      throw new Error("Invalid persisted organization member");
+    const key = JSON.stringify([member.subject.realmId, member.subject.subjectId]);
+    if (subjects.has(key))
+      throw new Error("Duplicate persisted organization member");
+    subjects.add(key);
+  }
+  const invitations = new Set;
+  for (const invite of state.invitations) {
+    if (!invite || !validText(invite.id, 256) || invite.organizationId !== state.organization.id || !validSubject(invite.target) || !validSubject(invite.createdBy) || invite.role !== "member" || !validTime(invite.createdAt) || !validTime(invite.expiresAt) || invite.expiresAt <= invite.createdAt || !["pending", "accepted", "revoked"].includes(invite.status) || (invite.status === "pending" ? invite.resolvedAt !== null : !validTime(invite.resolvedAt)) || typeof invite.tokenDigest !== "string" || !/^[a-f0-9]{64}$/.test(invite.tokenDigest) || invitations.has(invite.id))
+      throw new Error("Invalid persisted organization invitation");
+    invitations.add(invite.id);
+  }
+}
+function validText(value, max) {
+  return typeof value === "string" && !!value.trim() && value.length <= max;
+}
+function validTime(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function validSubject(value) {
+  return !!value && validText(value.realmId, 256) && validText(value.subjectId, 512);
+}
+function encodeState(state) {
+  validateState(state);
+  assertSnapshotCapacity(state);
+  return JSON.stringify(state);
+}
+function decodeSnapshot(id, version, encoded, observedAt) {
+  assertValidVersion(version, "row version");
+  let state;
+  try {
+    state = JSON.parse(encoded);
+  } catch {
+    throw new Error("Invalid persisted organization state");
+  }
+  validateState(state);
+  const decoded = state;
+  if (decoded.organization.id !== id || decoded.organization.version !== version) {
+    throw new Error("Organization row and state are inconsistent");
+  }
+  if (!validTime(observedAt))
+    throw new Error("Invalid organization storage clock");
+  return { state: decoded, observedAt };
+}
+
+export { assertValidVersion, validateState, encodeState, decodeSnapshot };

package/dist/index-ar1vwj4s.js

@@ -0,0 +1,370 @@
+import {
+  sameSubject2,
+  preserveOwners
+} from "./index-kdetdk6w.js";
+import {
+  assertSnapshotCapacity
+} from "./index-qgnmjsxx.js";
+import {
+  OrganizationError2
+} from "./index-tsx842dx.js";
+
+// src/service.ts
+var defaults = {
+  invitationLifetimeMs: 7 * 24 * 60 * 60 * 1000,
+  maxMembers: 1000,
+  maxInvitations: 1000,
+  conflictRetries: 8
+};
+function fail(code) {
+  throw new OrganizationError2(code);
+}
+function object(value, keys) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Object.keys(value).some((key) => !keys.includes(key)))
+    fail("INVALID_INPUT");
+  return value;
+}
+function text(value, maximum = 512) {
+  if (typeof value !== "string" || !value.trim() || value.length > maximum)
+    fail("INVALID_INPUT");
+  return value;
+}
+function subject(value) {
+  const input = object(value, ["realmId", "subjectId"]);
+  return { realmId: text(input.realmId, 256), subjectId: text(input.subjectId) };
+}
+function integer(value, min, max) {
+  if (!Number.isSafeInteger(value) || value < min || value > max) {
+    fail("INVALID_INPUT");
+  }
+  return value;
+}
+function resolveOrganizationConfig2(input = {}) {
+  const values = { ...defaults, ...object(input, Object.keys(defaults)) };
+  return Object.freeze({
+    invitationLifetimeMs: integer(values.invitationLifetimeMs, 1000, 30 * 24 * 60 * 60 * 1000),
+    maxMembers: integer(values.maxMembers, 1, 1000),
+    maxInvitations: integer(values.maxInvitations, 1, 1000),
+    conflictRetries: integer(values.conflictRetries, 0, 32)
+  });
+}
+function scoped(input, extra = []) {
+  const parsed = object(input, ["organizationId", ...extra]);
+  return { parsed, organizationId: text(parsed.organizationId, 256) };
+}
+function member(state, target) {
+  return state.members.find((item) => sameSubject2(item.subject, target)) ?? fail("NOT_FOUND");
+}
+function invitation(state, id) {
+  return state.invitations.find((item) => item.id === id) ?? fail("NOT_FOUND");
+}
+function present(invite, now) {
+  const { tokenDigest: _digest, ...result } = invite;
+  return {
+    ...result,
+    status: result.status === "pending" && result.expiresAt <= now ? "expired" : result.status
+  };
+}
+function pending(invite, now) {
+  if (invite.status === "accepted")
+    fail("INVITATION_ACCEPTED");
+  if (invite.status === "revoked")
+    fail("INVITATION_REVOKED");
+  if (invite.expiresAt <= now)
+    fail("INVITATION_EXPIRED");
+}
+function revokePendingFor(state, target, now) {
+  for (const invite of state.invitations) {
+    if (invite.status === "pending" && sameSubject2(invite.target, target)) {
+      invite.status = "revoked";
+      invite.resolvedAt = now;
+    }
+  }
+}
+async function digest(invite, bearer) {
+  const data = JSON.stringify([
+    invite.organizationId,
+    invite.id,
+    invite.target.realmId,
+    invite.target.subjectId,
+    invite.role,
+    invite.expiresAt,
+    bearer
+  ]);
+  return Array.from(new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(data))), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function token() {
+  return Array.from(crypto.getRandomValues(new Uint8Array(32)), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function equalDigest(a, b) {
+  let difference = a.length ^ b.length;
+  for (let i = 0;i < Math.max(a.length, b.length); i++) {
+    difference |= (a.charCodeAt(i) || 0) ^ (b.charCodeAt(i) || 0);
+  }
+  return difference === 0;
+}
+function createOrganizationService2(options) {
+  const config = resolveOrganizationConfig2(options.config);
+  const { store, access } = options;
+  async function authorize(actor, action, organizationId, state, target, details) {
+    const verified = await access.check(actor, structuredClone({
+      action,
+      organizationId,
+      organization: state?.organization ?? null,
+      members: state?.members ?? [],
+      ...target ? { target } : {},
+      ...details
+    }));
+    return subject({ realmId: verified?.realmId, subjectId: verified?.subjectId });
+  }
+  async function load(actor, action, organizationId, target, details) {
+    const snapshot = await store.read(organizationId);
+    const invite = details?.invitationId ? snapshot?.state.invitations.find((item) => item.id === details.invitationId) : undefined;
+    const principal = await authorize(actor, action, organizationId, snapshot?.state ?? null, invite?.target ?? target, {
+      ...details,
+      ...details?.invitationId ? { invitation: invite && snapshot ? present(invite, snapshot.observedAt) : null } : {}
+    });
+    if (!snapshot)
+      fail("NOT_FOUND");
+    if (snapshot.state.organization.id !== organizationId)
+      fail("NOT_FOUND");
+    return { ...snapshot, principal };
+  }
+  function capacity(state, previous) {
+    preserveOwners(state.members);
+    if (state.members.length > Math.max(config.maxMembers, previous?.members.length ?? 0) || state.invitations.length > Math.max(config.maxInvitations, previous?.invitations.length ?? 0))
+      fail("CAPACITY");
+    assertSnapshotCapacity(state);
+  }
+  async function mutate(actor, action, organizationId, target, change, details) {
+    for (let attempt = 0;attempt <= config.conflictRetries; attempt++) {
+      const snapshot = await load(actor, action, organizationId, target, details);
+      const next = structuredClone(snapshot.state);
+      const result = await change(next, snapshot.principal, snapshot.observedAt);
+      const expected = snapshot.state.organization.version;
+      integer(expected, 1, Number.MAX_SAFE_INTEGER - 1);
+      next.organization.version = expected + 1;
+      next.organization.updatedAt = snapshot.observedAt;
+      capacity(next, snapshot.state);
+      if (await store.compareAndSwap(expected, next, result.validUntil)) {
+        const changeInfo = {
+          organizationId,
+          version: next.organization.version,
+          action,
+          subjects: structuredClone(result.subjects ?? [])
+        };
+        return { value: structuredClone(result.value), change: changeInfo };
+      }
+    }
+    return fail("CONFLICT");
+  }
+  return {
+    async createOrganization(actor, input) {
+      const name = text(object(input, ["name"]).name, 200).trim();
+      const principal = await authorize(actor, "organization.create", null, null);
+      const now = Date.now();
+      const organization = {
+        id: crypto.randomUUID(),
+        name,
+        version: 1,
+        createdAt: now,
+        updatedAt: now
+      };
+      const state = {
+        organization,
+        members: [{ subject: principal, role: "owner", joinedAt: now }],
+        invitations: []
+      };
+      capacity(state);
+      await store.create(state);
+      return {
+        value: structuredClone(organization),
+        change: {
+          organizationId: organization.id,
+          version: 1,
+          action: "organization.create",
+          subjects: [principal]
+        }
+      };
+    },
+    async readOrganization(actor, input) {
+      const { organizationId } = scoped(input);
+      return structuredClone((await load(actor, "organization.read", organizationId)).state.organization);
+    },
+    async updateOrganization(actor, input) {
+      const { organizationId, parsed } = scoped(input, ["name"]);
+      const name = text(parsed.name, 200).trim();
+      const result = await mutate(actor, "organization.update", organizationId, undefined, (state) => {
+        state.organization.name = name;
+        return { value: state.organization };
+      });
+      return result;
+    },
+    async listMembers(actor, input) {
+      const { organizationId } = scoped(input);
+      const { state } = await load(actor, "member.list", organizationId);
+      return {
+        items: structuredClone(state.members),
+        total: state.members.length,
+        version: state.organization.version
+      };
+    },
+    async addMember(actor, input) {
+      const { organizationId, parsed } = scoped(input, ["subject"]);
+      const target = subject(parsed.subject);
+      return mutate(actor, "member.add", organizationId, target, (state, _principal, now) => {
+        if (state.members.some((item) => sameSubject2(item.subject, target)))
+          fail("ALREADY_MEMBER");
+        const added = { subject: target, role: "member", joinedAt: now };
+        state.members.push(added);
+        return { value: added, subjects: [target] };
+      });
+    },
+    async leaveOrganization(actor, input) {
+      const { organizationId } = scoped(input);
+      return mutate(actor, "member.leave", organizationId, undefined, (state, principal, now) => {
+        member(state, principal);
+        state.members = state.members.filter((item) => !sameSubject2(item.subject, principal));
+        preserveOwners(state.members);
+        revokePendingFor(state, principal, now);
+        return { value: true, subjects: [principal] };
+      });
+    },
+    async removeMember(actor, input) {
+      const { organizationId, parsed } = scoped(input, ["subject"]);
+      const target = subject(parsed.subject);
+      return mutate(actor, "member.remove", organizationId, target, (state, _principal, now) => {
+        member(state, target);
+        state.members = state.members.filter((item) => !sameSubject2(item.subject, target));
+        preserveOwners(state.members);
+        revokePendingFor(state, target, now);
+        return { value: true, subjects: [target] };
+      });
+    },
+    async setMemberRole(actor, input) {
+      const { organizationId, parsed } = scoped(input, ["subject", "role"]);
+      const target = subject(parsed.subject);
+      if (parsed.role !== "member" && parsed.role !== "admin")
+        fail("INVALID_INPUT");
+      const role = parsed.role;
+      return mutate(actor, "member.role", organizationId, target, (state, principal) => {
+        const item = member(state, target);
+        if (sameSubject2(principal, target) && item.role === "member" && role === "admin")
+          fail("FORBIDDEN");
+        item.role = role;
+        preserveOwners(state.members);
+        return { value: item, subjects: [target] };
+      }, { requestedRole: role });
+    },
+    async grantOwner(actor, input) {
+      const { organizationId, parsed } = scoped(input, ["subject"]);
+      const target = subject(parsed.subject);
+      return mutate(actor, "owner.grant", organizationId, target, (state, principal) => {
+        if (sameSubject2(principal, target))
+          fail("FORBIDDEN");
+        const item = member(state, target);
+        item.role = "owner";
+        return { value: item, subjects: [target] };
+      }, { requestedRole: "owner" });
+    },
+    async transferOwner(actor, input) {
+      const { organizationId, parsed } = scoped(input, ["subject"]);
+      const target = subject(parsed.subject);
+      return mutate(actor, "owner.transfer", organizationId, target, (state, principal) => {
+        if (sameSubject2(principal, target))
+          fail("INVALID_INPUT");
+        const previous = member(state, principal);
+        if (previous.role !== "owner")
+          fail("FORBIDDEN");
+        const next = member(state, target);
+        previous.role = "member";
+        next.role = "owner";
+        return { value: next, subjects: [principal, target] };
+      }, { requestedRole: "owner" });
+    },
+    async createInvitation(actor, input) {
+      const { organizationId, parsed } = scoped(input, ["target"]);
+      const target = subject(parsed.target);
+      const bearer = token();
+      const id = crypto.randomUUID();
+      return mutate(actor, "invitation.create", organizationId, target, async (state, principal, now) => {
+        if (state.members.some((item) => sameSubject2(item.subject, target)))
+          fail("ALREADY_MEMBER");
+        const invite = {
+          id,
+          organizationId,
+          target,
+          role: "member",
+          createdBy: principal,
+          createdAt: now,
+          expiresAt: now + config.invitationLifetimeMs,
+          status: "pending",
+          resolvedAt: null,
+          tokenDigest: ""
+        };
+        invite.tokenDigest = await digest(invite, bearer);
+        state.invitations.push(invite);
+        return { value: { invitation: present(invite, now), token: bearer } };
+      });
+    },
+    async readInvitation(actor, input) {
+      const { organizationId, parsed } = scoped(input, ["invitationId"]);
+      const id = text(parsed.invitationId, 256);
+      const { state, observedAt } = await load(actor, "invitation.read", organizationId, undefined, { invitationId: id });
+      return present(invitation(state, id), observedAt);
+    },
+    async listInvitations(actor, input) {
+      const { organizationId } = scoped(input);
+      const { state, observedAt } = await load(actor, "invitation.list", organizationId);
+      return {
+        items: state.invitations.map((invite) => present(invite, observedAt)),
+        total: state.invitations.length,
+        version: state.organization.version
+      };
+    },
+    async acceptInvitation(actor, input) {
+      const { organizationId, parsed } = scoped(input, ["invitationId", "token"]);
+      const id = text(parsed.invitationId, 256);
+      const bearer = text(parsed.token, 64);
+      if (!/^[a-f0-9]{64}$/.test(bearer))
+        fail("INVALID_INPUT");
+      return mutate(actor, "invitation.accept", organizationId, undefined, async (state, principal, now) => {
+        const invite = invitation(state, id);
+        if (!sameSubject2(invite.target, principal) || !equalDigest(invite.tokenDigest, await digest(invite, bearer)))
+          fail("NOT_FOUND");
+        pending(invite, now);
+        if (state.members.some((item) => sameSubject2(item.subject, principal)))
+          fail("ALREADY_MEMBER");
+        const joined = { subject: principal, role: "member", joinedAt: now };
+        state.members.push(joined);
+        invite.status = "accepted";
+        invite.resolvedAt = now;
+        return { value: joined, subjects: [principal], validUntil: invite.expiresAt };
+      }, { invitationId: id });
+    },
+    async revokeInvitation(actor, input) {
+      const { organizationId, parsed } = scoped(input, ["invitationId"]);
+      const id = text(parsed.invitationId, 256);
+      return mutate(actor, "invitation.revoke", organizationId, undefined, (state, _principal, now) => {
+        const invite = invitation(state, id);
+        pending(invite, now);
+        invite.status = "revoked";
+        invite.resolvedAt = now;
+        return { value: present(invite, now) };
+      }, { invitationId: id });
+    },
+    async pruneInvitations(actor, input) {
+      const { organizationId, parsed } = scoped(input, ["before"]);
+      const before = integer(parsed.before, 0, Number.MAX_SAFE_INTEGER);
+      return mutate(actor, "invitation.prune", organizationId, undefined, (state, _principal, now) => {
+        if (before > now)
+          fail("INVALID_INPUT");
+        const previous = state.invitations.length;
+        state.invitations = state.invitations.filter((invite) => (invite.status === "pending" ? invite.expiresAt : invite.resolvedAt) >= before);
+        return { value: previous - state.invitations.length };
+      });
+    }
+  };
+}
+
+export { resolveOrganizationConfig2, createOrganizationService2 };

package/dist/index-kdetdk6w.js

@@ -0,0 +1,39 @@
+import {
+  OrganizationError2
+} from "./index-tsx842dx.js";
+
+// src/policy.ts
+function sameSubject2(a, b) {
+  return a.realmId === b.realmId && a.subjectId === b.subjectId;
+}
+function memberRelationshipPolicy2(subject, request) {
+  if (request.action === "organization.create")
+    return true;
+  if (!request.organization)
+    return false;
+  if (request.action === "invitation.accept")
+    return true;
+  const member = request.members.find((item) => sameSubject2(item.subject, subject));
+  if (!member)
+    return false;
+  if (request.action === "member.leave")
+    return true;
+  if (request.action === "organization.read" || request.action === "member.list")
+    return true;
+  if (request.action === "owner.transfer" || request.action === "owner.grant" || request.action === "member.role") {
+    return member.role === "owner";
+  }
+  if (request.target) {
+    const target = request.members.find((item) => sameSubject2(item.subject, request.target));
+    if (target && target.role !== "member" && member.role !== "owner")
+      return false;
+  }
+  return member.role === "owner" || member.role === "admin";
+}
+function preserveOwners(members) {
+  if (!members.some((member) => member.role === "owner")) {
+    throw new OrganizationError2("LAST_OWNER");
+  }
+}
+
+export { sameSubject2, memberRelationshipPolicy2, preserveOwners };

package/dist/index-qgnmjsxx.js

@@ -0,0 +1,15 @@
+import {
+  OrganizationError2
+} from "./index-tsx842dx.js";
+
+// src/capacity.ts
+var maximumSnapshotBytes = 512000;
+function assertSnapshotCapacity(state) {
+  const bytes = new TextEncoder().encode(JSON.stringify(state)).byteLength;
+  const pending = state.invitations.filter((invite) => invite.status === "pending").length;
+  const headroom = pending * 12 + 16 - String(state.organization.updatedAt).length + 16 - String(state.organization.version).length;
+  if (bytes + headroom > maximumSnapshotBytes)
+    throw new OrganizationError2("CAPACITY");
+}
+
+export { assertSnapshotCapacity };

package/dist/index-tsx842dx.js

@@ -0,0 +1,11 @@
+// src/contracts.ts
+class OrganizationError2 extends Error {
+  code;
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "OrganizationError";
+  }
+}
+
+export { OrganizationError2 };

package/dist/index-zjdv6bc6.js

@@ -0,0 +1,9 @@
+// src/drizzle/schema-pg.ts
+import { bigint, pgTable, text } from "drizzle-orm/pg-core";
+var organizations2 = pgTable("organizations", {
+  id: text("id").primaryKey(),
+  version: bigint("version", { mode: "number" }).notNull(),
+  state: text("state").notNull()
+});
+
+export { organizations2 };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./contracts";
+export { createOrganizationService, resolveOrganizationConfig } from "./service";
+export type { OrganizationService } from "./service";
+export { memberRelationshipPolicy, sameSubject } from "./policy";

package/dist/index.js

@@ -0,0 +1,18 @@
+import {
+  resolveOrganizationConfig2,
+  createOrganizationService2
+} from "./index-ar1vwj4s.js";
+import {
+  sameSubject2,
+  memberRelationshipPolicy2
+} from "./index-kdetdk6w.js";
+import {
+  OrganizationError2
+} from "./index-tsx842dx.js";
+export {
+  OrganizationError2 as OrganizationError,
+  createOrganizationService2 as createOrganizationService,
+  memberRelationshipPolicy2 as memberRelationshipPolicy,
+  resolveOrganizationConfig2 as resolveOrganizationConfig,
+  sameSubject2 as sameSubject
+};

package/dist/plugin.d.ts

@@ -0,0 +1,11 @@
+import { type Plugin } from "@lenso/core/plugin";
+import type { OrganizationAccess, OrganizationConfig, OrganizationStore } from "./contracts";
+import { type OrganizationService } from "./service";
+/** Borrow exact database/access instances; their owners retain cleanup. */
+export declare function createOrganizationPlugin<Database, Actor>(options: {
+    id: string;
+    database: Plugin<Database>;
+    access: Plugin<OrganizationAccess<Actor>>;
+    store(database: Database): OrganizationStore;
+    config?: Partial<OrganizationConfig>;
+}): Plugin<OrganizationService<Actor>>;

package/dist/plugin.js

@@ -0,0 +1,22 @@
+import {
+  createOrganizationService2
+} from "./index-ar1vwj4s.js";
+
+// src/plugin.ts
+import { definePlugin } from "@lenso/core/plugin";
+function createOrganizationPlugin(options) {
+  return definePlugin({
+    id: options.id,
+    requires: [options.database, options.access],
+    setup(context) {
+      return createOrganizationService2({
+        store: options.store(context.get(options.database)),
+        access: context.get(options.access),
+        config: options.config
+      });
+    }
+  });
+}
+export {
+  createOrganizationPlugin
+};

package/dist/policy.d.ts

@@ -0,0 +1,9 @@
+import { type AccessRequest, type Member, type SubjectRef } from "./contracts";
+export declare function sameSubject(a: SubjectRef, b: SubjectRef): boolean;
+/**
+ * Opt-in business relationship policy, never Console/platform admission.
+ * Caller must authenticate the subject first. No role implies permission unless
+ * the application chooses this policy or another explicit authorization policy.
+ */
+export declare function memberRelationshipPolicy(subject: SubjectRef, request: AccessRequest): boolean;
+export declare function preserveOwners(members: readonly Member[]): void;

package/dist/service.d.ts

@@ -0,0 +1,86 @@
+import { type Invitation, type Member, type MutationResult, type Organization, type OrganizationAccess, type OrganizationConfig, type OrganizationStore, type SubjectRef } from "./contracts";
+export declare function resolveOrganizationConfig(input?: Partial<OrganizationConfig>): OrganizationConfig;
+/**
+ * Ordinary async service. Stores/access providers are borrowed. Notification is
+ * deliberately outside this commit boundary: send only after createInvitation
+ * returns, and never log its returned bearer token.
+ */
+export declare function createOrganizationService<Actor>(options: {
+    store: OrganizationStore;
+    access: OrganizationAccess<Actor>;
+    config?: Partial<OrganizationConfig>;
+}): {
+    createOrganization(actor: Actor, input: {
+        name: string;
+    }): Promise<MutationResult<Organization>>;
+    readOrganization(actor: Actor, input: {
+        organizationId: string;
+    }): Promise<Organization>;
+    updateOrganization(actor: Actor, input: {
+        organizationId: string;
+        name: string;
+    }): Promise<MutationResult<Organization>>;
+    listMembers(actor: Actor, input: {
+        organizationId: string;
+    }): Promise<{
+        items: Member[];
+        total: number;
+        version: number;
+    }>;
+    addMember(actor: Actor, input: {
+        organizationId: string;
+        subject: SubjectRef;
+    }): Promise<MutationResult<Member>>;
+    leaveOrganization(actor: Actor, input: {
+        organizationId: string;
+    }): Promise<MutationResult<boolean>>;
+    removeMember(actor: Actor, input: {
+        organizationId: string;
+        subject: SubjectRef;
+    }): Promise<MutationResult<boolean>>;
+    setMemberRole(actor: Actor, input: {
+        organizationId: string;
+        subject: SubjectRef;
+        role: "member" | "admin";
+    }): Promise<MutationResult<Member>>;
+    grantOwner(actor: Actor, input: {
+        organizationId: string;
+        subject: SubjectRef;
+    }): Promise<MutationResult<Member>>;
+    transferOwner(actor: Actor, input: {
+        organizationId: string;
+        subject: SubjectRef;
+    }): Promise<MutationResult<Member>>;
+    createInvitation(actor: Actor, input: {
+        organizationId: string;
+        target: SubjectRef;
+    }): Promise<MutationResult<{
+        invitation: Invitation;
+        token: string;
+    }>>;
+    readInvitation(actor: Actor, input: {
+        organizationId: string;
+        invitationId: string;
+    }): Promise<Invitation>;
+    listInvitations(actor: Actor, input: {
+        organizationId: string;
+    }): Promise<{
+        items: Invitation[];
+        total: number;
+        version: number;
+    }>;
+    acceptInvitation(actor: Actor, input: {
+        organizationId: string;
+        invitationId: string;
+        token: string;
+    }): Promise<MutationResult<Member>>;
+    revokeInvitation(actor: Actor, input: {
+        organizationId: string;
+        invitationId: string;
+    }): Promise<MutationResult<Invitation>>;
+    pruneInvitations(actor: Actor, input: {
+        organizationId: string;
+        before: number;
+    }): Promise<MutationResult<number>>;
+};
+export type OrganizationService<Actor> = ReturnType<typeof createOrganizationService<Actor>>;

package/migrations/pg/0000_organizations.sql

@@ -0,0 +1,5 @@
+CREATE TABLE organizations (
+  id text PRIMARY KEY,
+  version bigint NOT NULL CHECK (version BETWEEN 1 AND 9007199254740991),
+  state text NOT NULL CHECK (jsonb_typeof(state::jsonb) = 'object')
+);