// keyed routers enforce a single-writer for all methods of a router
// the second function parameter (the key) defines the single-writer identity
const userService = keyedRouter({

  updateUser: async (ctx: RpcContext, userId: string, update: any) => {...},

  moveUser: async (ctx: RpcContext, userId: string, move: any) => {...},

  deleteUser: async (ctx: RpcContext, userId: string) => {...}
});
                        

// make calls from Restate to a service idempotently across retries/suspensions
async function invoke(ctx: restate.RpcContext, request: RequestType) {

  // deterministic random takes part in durable execution
  const idempotencyToken = ctx.rand.uuidv4();

  // side effect captures response and avoids retries after first success
  await ctx.sideEffect(() => api.makeCall(request, idempotencyToken));
}

// invoke functions idempotently from external clients
`curl http://<restate>/myservice/invoke -H 'idempotency-key: <key>' --json '{"request": {...}}'`
                        

const handleWorkflow = async (ctx: restate.RpcContext, req: Request) => {
  // create a promise/future that can be completed externally
  const restatePromise = await ctx.awakeable();

  // pass the promise ID along with the call to external system
  await ctx.sideEffect(() => clnt.doSomething(restatePromise.id))

  // blocks (and suspends) until the promise is completed by external system
  await restatePromise.promise;
};
                        

// function will automatically journal actions and recover from partial
// progress to ensure all writes get applied
async function applyChange(ctx: restate.RpcContext, request: UpdateRequest) {

  // write 1: Update the database. Will be automatically retried on failure.
  const clientToken = ctx.rand.uuidv4();
  await ctx.sideEffect(() =>
      dynamodb.idempotentInsert(request.dbUpdateRecord, clientToken));

  // write 2: send a message
  ctx.send(messageSender).publish(request.kafkaMessage);

  // write 3: set some Restate state
  ctx.set("status", request);
};
                        

const handleWorkflow = async (ctx: restate.RpcContext, req: Request) => {
 // do something

 // delayed background task that will execute exactly once
 ctx.sendDelayed(otherService, 10_000).doSmt(req);
};
                        

const lockService = restate.keyedRouter({

  tryAcquire: async (ctx: restate.RpcContext, lockId: string) => {
    const lockHolder = await ctx.get<string>(LOCK_HOLDER_STATE);
    if (lockHolder !== null) {
      return { acquired: false } as LockAcquisition;
    }

    const fencingToken = ctx.rand.uuidv4();
    ctx.set(LOCK_HOLDER_STATE, fencingToken);
    return { acquired: true, fencingToken } as LockAcquisition;
  },
  acquire:   ...,
  release:   ...,
  holdsLock: ...,
});