@akterjs/effect 0.0.0-stage → 0.1.0

package/src/contract/hosted/hosted-create.service.ts

@@ -0,0 +1,95 @@
+import { Context, Effect, Exit, Layer, Option, Schema } from "effect";
+
+import { ActorAlreadyExistsError } from "#src/contract/actor/actor-already-exists.errors";
+import type {
+  CommandEnvironment,
+  HostedError,
+  HostedOutcome,
+  HostedRequest,
+  StateFields,
+} from "#src/contract/actor/actor.contract";
+import {
+  noJobs,
+  noMessages,
+  noSignals,
+  noTimers,
+  refusedActorState,
+  scopeOf,
+} from "#src/contract/state/actor-state.pure";
+import { admit } from "#src/contract/caller/caller-admission.pure";
+import { command } from "#src/contract/command/command.contract";
+import { rejectFailedStatement } from "./handler-failure.pure.js";
+import { decodeRequest } from "./hosted-request.pure.js";
+import type { ErasedParts } from "./hosted-request.pure.js";
+import { InvalidRequestError } from "#src/contract/client/invalid-request.errors";
+import { exitCodec, jsonCodec } from "#src/contract/json-codec.pure";
+
+const creation = command({ success: Schema.Void });
+
+const firstState = (parts: ErasedParts, exit: Exit.Exit<StateFields>): Effect.Effect<Option.Option<string>> => {
+  const encode = Schema.encodeEffect(jsonCodec(parts.definition.state));
+
+  return Effect.transposeOption(Option.map(Exit.getSuccess(exit), (state) => Effect.orDie(encode(state))));
+};
+
+const createdBy = Effect.fnUntraced(function* createdBy(
+  parts: ErasedParts,
+  request: HostedRequest,
+  environment: CommandEnvironment,
+): Effect.fn.Return<HostedOutcome, HostedError> {
+  const create = yield* Effect.mapError(Effect.fromOption(Option.fromNullishOr(parts.implementation.create)), () =>
+    InvalidRequestError.make({ actor: parts.name, message: `${parts.name} has no create handler` }),
+  );
+
+  const input = yield* decodeRequest({ actor: parts.name, schema: parts.definition.create, text: request.payload });
+
+  const principal = yield* admit({
+    actor: parts.name,
+    allowed: Option.none(),
+    callers: parts.definition.callers,
+    member: request.member,
+    principal: request.principal,
+  });
+
+  const finished = yield* Effect.exit(
+    parts.provide(create(input), scopeOf({ environment, principal }), refusedActorState),
+  );
+
+  const exit = yield* rejectFailedStatement(finished, { actor: parts.name, member: request.member });
+  const reply = yield* Effect.orDie(Schema.encodeEffect(exitCodec(creation))(Exit.asVoid(exit)));
+  const state = yield* firstState(parts, exit);
+
+  return { exit: reply, jobs: noJobs, messages: noMessages, signals: noSignals, state, timers: noTimers };
+});
+
+const runCreate = Effect.fn("HostedActor.runCreate")(function* runCreate(
+  parts: ErasedParts,
+  request: HostedRequest,
+  environment: CommandEnvironment,
+): Effect.fn.Return<HostedOutcome, HostedError> {
+  if (Option.isNone(request.state)) {
+    return yield* createdBy(parts, request, environment);
+  }
+
+  if (request.member !== "ensure") {
+    return yield* ActorAlreadyExistsError.make({ actor: parts.name });
+  }
+
+  const reply = yield* Effect.orDie(Schema.encodeEffect(exitCodec(creation))(Exit.void));
+
+  return {
+    exit: reply,
+    jobs: noJobs,
+    messages: noMessages,
+    signals: noSignals,
+    state: Option.none(),
+    timers: noTimers,
+  };
+});
+
+export class HostedCreate extends Context.Service<HostedCreate, { readonly run: typeof runCreate }>()(
+  "@akterjs/effect/contract/hosted/hosted-create.service/HostedCreate",
+  { make: Effect.succeed({ run: runCreate }) },
+) {
+  public static readonly layer = Layer.effect(this, this.make);
+}

package/src/contract/hosted/hosted-error.contract.ts

@@ -0,0 +1,22 @@
+import type { ActorAlreadyExistsError } from "#src/contract/actor/actor-already-exists.errors";
+import type { ActorErasedError } from "#src/contract/actor/actor-erased.errors";
+import type { ActorNotCreatedError } from "#src/contract/actor/actor-not-created.errors";
+import type { CallerNotAllowedError } from "#src/contract/caller/caller-not-allowed.errors";
+import type { CommandIdExpiredError } from "#src/contract/command/command-id-expired.errors";
+import type { HandlerFailedError } from "./handler-failed.errors.js";
+import type { InvalidRequestError } from "#src/contract/client/invalid-request.errors";
+
+type HostedError =
+  | ActorAlreadyExistsError
+  | ActorErasedError
+  | ActorNotCreatedError
+  | CallerNotAllowedError
+  | CommandIdExpiredError
+  | HandlerFailedError
+  | InvalidRequestError;
+
+export type { HostedError };
+
+export type { StateUnreadableError } from "#src/contract/state/state-unreadable.errors";
+
+export type { HostedOutcome } from "#src/contract/hosted/hosted-outcome.contract";

package/src/contract/hosted/hosted-failure.schema.ts

@@ -0,0 +1,32 @@
+import { Schema } from "effect";
+
+import {
+  ActorErasedError,
+  ActorNotCreatedError,
+  ActorUnavailableError,
+  BillingUnavailableError,
+  CallerNotAllowedError,
+  CommandIdExpiredError,
+  HandlerFailedError,
+  InvalidRequestError,
+  SpendCapReachedError,
+  StorageLimitError,
+} from "#src/contract/client/client-failure.contract";
+
+/**
+ * The failures any hosted member can answer besides its declared ones. Akter Cloud's gateway also answers
+ * `SpendCapReachedError` and `BillingUnavailableError` when it refuses new spend, and its hosts answer
+ * `StorageLimitError` when a write would grow storage past its ceiling, so clients decode those typed.
+ */
+export const HostedFailure = Schema.Union([
+  ActorErasedError,
+  ActorNotCreatedError,
+  ActorUnavailableError,
+  BillingUnavailableError,
+  CallerNotAllowedError,
+  CommandIdExpiredError,
+  HandlerFailedError,
+  InvalidRequestError,
+  SpendCapReachedError,
+  StorageLimitError,
+]);

package/src/contract/hosted/hosted-outcome.contract.ts

@@ -0,0 +1,21 @@
+import type { Option } from "effect";
+
+import type { OutboxMessage } from "#src/contract/command/outbox.schema";
+import type { TimerChanges } from "#src/contract/command/timer.schema";
+import type { StartedJob } from "#src/contract/job/started-job.schema";
+import type { JobSignal } from "#src/contract/job/job-signal.schema";
+
+interface HostedOutcome {
+  readonly exit: string;
+  readonly jobs: readonly StartedJob[];
+  readonly messages: readonly OutboxMessage[];
+  /**
+   * Signals to the actor's own jobs, stored with the command and woken once it commits. An app built with akter before
+   * Akter.signal leaves it out, and a host serves that build as signalling nothing.
+   */
+  readonly signals?: readonly JobSignal[] | undefined;
+  readonly state: Option.Option<string>;
+  readonly timers: TimerChanges;
+}
+
+export type { HostedOutcome };

package/src/contract/hosted/hosted-query.service.ts

@@ -0,0 +1,50 @@
+import { Context, Effect, Layer, Option, Record as Rec, Schema } from "effect";
+
+import type { CommandEnvironment, HostedError, HostedRequest } from "#src/contract/actor/actor.contract";
+import { refusedActorState, scopeOf } from "#src/contract/state/actor-state.pure";
+import { rejectFailedStatement } from "./handler-failure.pure.js";
+import { prepare } from "./hosted-request.pure.js";
+import type { ErasedParts, Members } from "./hosted-request.pure.js";
+import { exitCodec } from "#src/contract/json-codec.pure";
+import { fileAccessMember } from "#src/contract/file/access/file-access.contract";
+
+/** The actor's queries, and its `files.authorize` rule as the reserved `akter.files` query when it declares files. */
+const queriesOf = ({ definition, implementation }: ErasedParts): Members => {
+  const rule = Option.all({
+    declaration: definition.fileAccess,
+    handler: Option.map(Option.fromNullishOr(implementation.files), (files) => files.authorize),
+  });
+
+  return Option.match(rule, {
+    onNone: () => ({ declarations: definition.queries, handlers: implementation.queries ?? {} }),
+    onSome: ({ declaration, handler }) => ({
+      declarations: Rec.set(definition.queries, fileAccessMember, declaration),
+      handlers: Rec.set(implementation.queries ?? {}, fileAccessMember, handler),
+    }),
+  });
+};
+
+const runQuery = Effect.fn("HostedActor.runQuery")(function* runQuery(
+  parts: ErasedParts,
+  request: HostedRequest,
+  environment: CommandEnvironment,
+): Effect.fn.Return<string, HostedError> {
+  const prepared = yield* prepare(parts, queriesOf(parts), request);
+
+  const scope = scopeOf({ environment, principal: prepared.principal });
+
+  const finished = yield* Effect.exit(
+    parts.provide(prepared.handler(prepared.state, prepared.payload), scope, refusedActorState),
+  );
+
+  const exit = yield* rejectFailedStatement(finished, { actor: parts.name, member: request.member, query: true });
+
+  return yield* Effect.orDie(Schema.encodeEffect(exitCodec(prepared.declaration))(exit));
+});
+
+export class HostedQuery extends Context.Service<HostedQuery, { readonly run: typeof runQuery }>()(
+  "@akterjs/effect/contract/hosted/hosted-query.service/HostedQuery",
+  { make: Effect.succeed({ run: runQuery }) },
+) {
+  public static readonly layer = Layer.effect(this, this.make);
+}

package/src/contract/hosted/hosted-request.pure.ts

@@ -0,0 +1,185 @@
+import { Effect, Option, Record as Rec, Schema } from "effect";
+
+import { ActorNotCreatedError } from "#src/contract/actor/actor-not-created.errors";
+import type { ActorState } from "#src/contract/state/actor-state.service";
+import type {
+  ActorDefinition,
+  CommandScope,
+  Decoded,
+  HostedError,
+  HostedRequest,
+  HostedResult,
+  Migrations,
+  StateFields,
+  StateMigration,
+  StateSchema,
+} from "#src/contract/actor/actor.contract";
+import type { Akter } from "#src/contract/akter.service";
+import { admit } from "#src/contract/caller/caller-admission.pure";
+import { jobResult } from "#src/contract/command/command.contract";
+import type { AnyCommand, AnyQuery, PlainSchema } from "#src/contract/command/command.contract";
+import { InvalidRequestError } from "#src/contract/client/invalid-request.errors";
+import { jsonCodec } from "#src/contract/json-codec.pure";
+import { ActorPrincipal } from "#src/contract/caller/principal.schema";
+import type { Principal } from "#src/contract/caller/principal.schema";
+
+type ErasedHandler = (state: StateFields, payload: Decoded) => Effect.Effect<never, never, Akter | ActorState>;
+
+type ErasedResultHandler = (
+  state: StateFields,
+  payload: Decoded,
+  job: { readonly id: string },
+) => Effect.Effect<never, never, Akter | ActorState>;
+
+type ErasedQueryHandler = (state: StateFields, payload: Decoded) => Effect.Effect<never, never, Akter>;
+
+type ErasedCreateHandler = (input: Decoded) => Effect.Effect<StateFields, never, Akter>;
+
+type ProvideScope = <Success, Failure>(
+  effect: Effect.Effect<Success, Failure, Akter | ActorState>,
+  scope: CommandScope,
+  state: ActorState["Service"],
+) => Effect.Effect<Success, Failure>;
+
+interface ErasedImplementation {
+  readonly commands: Readonly<Record<string, ErasedHandler>>;
+  readonly create?: ErasedCreateHandler;
+  readonly files?: { readonly authorize: ErasedQueryHandler };
+  readonly migrations?: Migrations;
+  readonly queries?: Readonly<Record<string, ErasedQueryHandler>>;
+  readonly results?: Readonly<Record<string, ErasedResultHandler>>;
+  readonly state?: StateMigration<StateFields>;
+}
+
+interface ErasedSpec {
+  readonly definition: ActorDefinition;
+  readonly initial: Option.Option<() => StateFields>;
+  readonly name: string;
+  readonly provide: ProvideScope;
+}
+
+interface ErasedParts extends ErasedSpec {
+  readonly implementation: ErasedImplementation;
+}
+
+interface Members {
+  readonly declarations: Readonly<Record<string, AnyCommand | AnyQuery>>;
+  readonly handlers: Readonly<Record<string, ErasedHandler>>;
+}
+
+interface Prepared {
+  readonly declaration: AnyCommand | AnyQuery;
+  readonly handler: ErasedHandler;
+  readonly payload: Decoded;
+  readonly principal: Principal;
+  readonly state: StateFields;
+}
+
+interface Decoding<Target extends PlainSchema> {
+  readonly actor: string;
+  readonly schema: Target;
+  readonly text: string;
+}
+
+const decodeRequest = <Target extends PlainSchema>({
+  actor,
+  schema,
+  text,
+}: Decoding<Target>): Effect.Effect<Target["Type"], InvalidRequestError> =>
+  Schema.decodeEffect(jsonCodec(schema))(text).pipe(
+    Effect.mapError((issue) => InvalidRequestError.make({ actor, message: issue.message })),
+  );
+
+interface StateSource {
+  readonly initial: Option.Option<() => StateFields>;
+  readonly name: string;
+  readonly state: StateSchema;
+}
+
+const startingState = Effect.fnUntraced(function* startingState(
+  source: StateSource,
+  stored: Option.Option<string>,
+): Effect.fn.Return<StateFields, HostedError> {
+  if (Option.isSome(stored)) {
+    return yield* decodeRequest({ actor: source.name, schema: source.state, text: stored.value });
+  }
+
+  if (Option.isNone(source.initial)) {
+    return yield* ActorNotCreatedError.make({ actor: source.name });
+  }
+
+  return source.initial.value();
+});
+
+const prepare = Effect.fnUntraced(function* prepare(
+  parts: ErasedParts,
+  members: Members,
+  request: HostedRequest,
+): Effect.fn.Return<Prepared, HostedError> {
+  const declaration = Rec.get(members.declarations, request.member);
+  const handler = Rec.get(members.handlers, request.member);
+
+  if (Option.isNone(declaration) || Option.isNone(handler)) {
+    return yield* InvalidRequestError.make({ actor: parts.name, message: `${request.member} is not a member` });
+  }
+
+  const principal = yield* admit({
+    actor: parts.name,
+    allowed: declaration.value.callers,
+    callers: parts.definition.callers,
+    member: request.member,
+    principal: request.principal,
+  });
+
+  const payload = yield* decodeRequest({ actor: parts.name, schema: declaration.value.payload, text: request.payload });
+
+  const state = yield* startingState(
+    { initial: parts.initial, name: parts.name, state: parts.definition.state },
+    request.state,
+  );
+
+  return { declaration: declaration.value, handler: handler.value, payload, principal, state };
+});
+
+const prepareResult = Effect.fnUntraced(function* prepareResult(
+  parts: ErasedParts,
+  request: HostedResult,
+): Effect.fn.Return<Prepared, HostedError> {
+  const job = Rec.get(parts.definition.jobs, request.member);
+  const handler = Rec.get(parts.implementation.results ?? {}, request.member);
+
+  if (Option.isNone(job) || Option.isNone(handler)) {
+    return yield* InvalidRequestError.make({
+      actor: parts.name,
+      message: `${request.member} is not a job with a result handler`,
+    });
+  }
+
+  const declaration: AnyCommand = {
+    callers: Option.none(),
+    error: Schema.Never,
+    payload: jobResult(job.value),
+    success: Schema.Void,
+  };
+
+  const { principal } = yield* decodeRequest({
+    actor: parts.name,
+    schema: Schema.Struct({ principal: ActorPrincipal }),
+    text: request.principal,
+  });
+
+  const payload = yield* decodeRequest({ actor: parts.name, schema: declaration.payload, text: request.payload });
+
+  const state = yield* startingState(
+    { initial: parts.initial, name: parts.name, state: parts.definition.state },
+    request.state,
+  );
+
+  const delivered: ErasedHandler = (current, result) => handler.value(current, result, { id: request.jobId });
+
+  return { declaration, handler: delivered, payload, principal, state };
+});
+
+export { decodeRequest, prepare, prepareResult, startingState };
+
+export type { ErasedImplementation, ErasedParts, ErasedSpec, Members, Prepared, ProvideScope, StateSource };

package/src/contract/job/job-id.pure.ts

@@ -0,0 +1,37 @@
+import { Array as Arr, Option, String as Str } from "effect";
+
+interface JobAddress {
+  readonly actor: string;
+  readonly key: string;
+}
+
+interface Minting extends JobAddress {
+  readonly id: string;
+}
+
+const separator = "/";
+
+const addressParts = 3;
+
+const actorPart = 0;
+
+const keyPart = 1;
+
+const jobIdOf = ({ actor, id, key }: Minting): string => Arr.join([actor, encodeURIComponent(key), id], separator);
+
+const jobAddress = (jobId: string): Option.Option<JobAddress> => {
+  const parts = Str.split(jobId, separator);
+
+  if (parts.length !== addressParts) {
+    return Option.none();
+  }
+
+  return Option.map(Option.all([Arr.get(parts, actorPart), Arr.get(parts, keyPart)]), ([actor, key]) => ({
+    actor,
+    key: decodeURIComponent(key),
+  }));
+};
+
+export { jobAddress, jobIdOf };
+
+export type { JobAddress };

package/src/contract/job/job-patches.contract.ts

@@ -0,0 +1,86 @@
+import { Array as Arr, Context, Effect, Option, Schema } from "effect";
+
+/**
+ * The payload key a job's stored payload carries its patches under: the patches its contract declared when a command
+ * started it. A job whose payload has none was started by code without patches.
+ */
+const patchesKey = "~akter/patches";
+
+/** Where a decoded payload keeps its patches on the way to the job's run: a symbol, so the run's payload stays its fields. */
+const carriedPatches: unique symbol = Symbol.for("@akterjs/effect/contract/job/job-patches.contract/carriedPatches");
+
+/** A decoded payload, which may carry the patches its start declared. */
+interface CarriedPayload {
+  readonly [carriedPatches]?: unknown;
+}
+
+const Patches = Schema.Array(Schema.String);
+
+const isPatches = Schema.is(Patches);
+
+/** The patches the running job started with; none outside a job's run. */
+const CurrentJobPatches = Context.Reference<Option.Option<readonly string[]>>(
+  "@akterjs/effect/contract/job/job-patches.contract/CurrentJobPatches",
+  { defaultValue: Option.none },
+);
+
+/**
+ * A decoded payload carrying the patches its start declared, hidden from its fields, so the job's run sees exactly the
+ * payload it declared and the patches stay out of `Object.keys`, equality and logs.
+ */
+const carrying = <Fields extends object>({
+  fields,
+  patches,
+}: {
+  readonly fields: Fields;
+  readonly patches: readonly string[] | undefined;
+}): Fields => {
+  if (Arr.isReadonlyArrayEmpty(patches ?? [])) {
+    return fields;
+  }
+
+  return Object.defineProperty(fields, carriedPatches, { enumerable: false, value: patches });
+};
+
+/** The patches a decoded payload carries, or none for a payload from code without patches. */
+const patchesOf = (payload: CarriedPayload): readonly string[] => {
+  const carried = payload[carriedPatches];
+
+  if (isPatches(carried)) {
+    return carried;
+  }
+
+  return [];
+};
+
+/** Runs a job's `execute` with the patches its stored payload carries. */
+const withPatches =
+  <Payload extends CarriedPayload, Success, Failure, Services>(
+    execute: (payload: Payload, executionId: string) => Effect.Effect<Success, Failure, Services>,
+  ) =>
+  (payload: Payload, executionId: string): Effect.Effect<Success, Failure, Services> =>
+    Effect.provideService(execute(payload, executionId), CurrentJobPatches, Option.some(patchesOf(payload)));
+
+/**
+ * A job's `patched(name)`: whether the running job was started by code that declared `name` in the job's patches. A
+ * job keeps the answer for its whole run, across restarts and deploys, so a job started before a deploy takes the old
+ * path to the end.
+ */
+const patchedOf =
+  ({ patches: declared, tag }: { readonly patches: readonly string[]; readonly tag: string }) =>
+  (name: string): Effect.Effect<boolean> =>
+    Effect.flatMap(
+      CurrentJobPatches,
+      Option.match({
+        onNone: () => Effect.die(`${tag}.patched("${name}") runs only inside the job's run`),
+        onSome: (patches) => {
+          if (!Arr.contains(declared, name)) {
+            return Effect.die(`${tag} declares no patch "${name}": add it to the job's patches in Akter.job`);
+          }
+
+          return Effect.succeed(Arr.contains(patches, name));
+        },
+      }),
+    );
+
+export { carriedPatches, carrying, patchedOf, patchesKey, withPatches };

package/src/contract/job/job-signal.schema.ts

@@ -0,0 +1,23 @@
+import { Schema } from "effect";
+import type { Exit } from "effect";
+
+const encodedValue = Schema.UndefinedOr(Schema.Json);
+
+const exitSchema = Schema.Exit(encodedValue, encodedValue, Schema.Defect());
+
+/** A job's exit as its journal keeps it: the exit its own schemas encoded, written as JSON text. */
+export const StoredExit: Schema.Codec<Exit.Exit<unknown, unknown>, string> = Schema.fromJsonString(
+  Schema.toCodecJson(exitSchema),
+);
+
+/**
+ * A signal a command sends one of its own actor's jobs (`Akter.signal`): the job's id, the durable deferred's name and
+ * the value as a stored exit. It is written with the command, so a command that rolls back sends nothing.
+ */
+export const JobSignal = Schema.Struct({
+  deferred: Schema.String,
+  exit: Schema.String,
+  id: Schema.String,
+});
+
+export type JobSignal = typeof JobSignal.Type;

package/src/contract/job/reserved-payload-field.errors.ts

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+
+/** A job's payload declares a field Akter keeps for itself, such as the patches its start stored (`~akter/patches`). */
+export class ReservedPayloadFieldError extends Schema.TaggedError<
+  ReservedPayloadFieldError,
+  { readonly brand: unique symbol }
+>()("ReservedPayloadFieldError", {
+  field: Schema.String,
+  job: Schema.String,
+}) {}

package/src/contract/job/started-job.schema.ts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+
+export const StartedJob = Schema.Struct({
+  id: Schema.String,
+  job: Schema.String,
+  payload: Schema.String,
+});
+
+export type StartedJob = typeof StartedJob.Type;

package/src/contract/json-codec.pure.ts

@@ -0,0 +1,27 @@
+import { Option, Schema } from "effect";
+import type { Exit } from "effect";
+
+import type { Decoded } from "#src/contract/actor/actor.contract";
+import type { AnyCommand, AnyQuery, PlainSchema } from "#src/contract/command/command.contract";
+
+type ExitCodec = Schema.Codec<Exit.Exit<Decoded, Decoded>, string>;
+
+const jsonCodec = <Target extends PlainSchema>(schema: Target): Schema.Codec<Target["Type"], string> =>
+  Schema.fromJsonString(Schema.toCodecJson(schema));
+
+/**
+ * Exit codecs by declaration. Building one derives the JSON codec of the whole Exit schema, about 25 times the cost of
+ * encoding a reply with it, and the engine encodes every command's and query's reply.
+ */
+const exitCodecs = new WeakMap<AnyCommand | AnyQuery, ExitCodec>();
+
+const exitCodec = (declaration: AnyCommand | AnyQuery): ExitCodec =>
+  Option.getOrElse(Option.fromUndefinedOr(exitCodecs.get(declaration)), () => {
+    const codec = jsonCodec(Schema.Exit(declaration.success, declaration.error, Schema.Defect()));
+
+    exitCodecs.set(declaration, codec);
+
+    return codec;
+  });
+
+export { exitCodec, jsonCodec };

package/src/contract/room.contract.ts

@@ -0,0 +1,31 @@
+import { Akter } from "@akterjs/effect/contract";
+import { Schema } from "effect";
+
+const RoomId = Schema.String.pipe(Schema.brand("RoomId"));
+
+type RoomId = typeof RoomId.Type;
+
+const Message = Schema.Struct({ at: Schema.Int, author: Schema.String, id: Schema.String, text: Schema.String });
+
+type Message = typeof Message.Type;
+
+class NotMemberError extends Schema.TaggedError<NotMemberError, { readonly brand: unique symbol }>()(
+  "NotMemberError",
+  {},
+) {}
+
+const Room = Akter.make("Room", {
+  commands: {
+    join: Akter.command({ success: Schema.Void }),
+    post: Akter.command({ error: NotMemberError, payload: { text: Schema.String }, success: Schema.String }),
+  },
+  files: Akter.fileAccess({ callers: ["user"] }),
+  initial: () => ({ members: [], title: "Untitled" }),
+  key: RoomId,
+  queries: {
+    messages: Akter.query({ payload: { limit: Schema.Int }, success: Schema.Array(Message) }),
+  },
+  state: Schema.Struct({ members: Schema.Array(Schema.String), title: Schema.String }),
+});
+
+export { Message, NotMemberError, Room, RoomId };