Keep your business functions. Add reusable action controls.

Without Core

The application leaves a later lookup to its own recovery flow.

export async function withoutCore(restaurant, request) {
  const binding = {
    ...request, tenantRef: 'tenant:demo',
    effectIdentity: `legacy:${request.requestId}`,
  };
  try {
    await restaurant.bookReservation(binding);
  } catch {
    try {
      const receipt = await restaurant.lookupReservation(
        binding.effectIdentity,
      );
      const exact = Object.keys(binding).every(
        field => receipt[field] === binding[field],
      );
      if (exact && receipt.status === 'reserved') {
        return 'Your table for two was verified.';
      }
    } catch {}
    return 'The booking outcome needs a later check. Do not resend.';
  }
  return 'The booking response needs an independent check.';
}

With Core

Step 1: Adapt your existing business functions

  async function dispatch({ input, context, operationIdentity, executionIdentity, effectIdentity, attemptIdentity }) {
    const entry = admissions.get(input.requestId);
    if (!entry || !sameInput(entry.input, input)) return { kind: 'PRECONDITION_FAILED' };
    const binding = { ...input, tenantRef: context.tenant.tenantRef, operationIdentity, executionIdentity, effectIdentity, attemptIdentity };
    entry.binding = binding;
    bindings.set(effectIdentity, binding);
    try {
      await restaurant.bookReservation(binding);
      return { kind: 'ACKNOWLEDGED' };
    } catch {
      return { kind: 'UNCERTAIN', reason: 'RESPONSE_LOST' };
    }
  }
  async function verify({ input, context, effectIdentity }) {
    const binding = bindings.get(effectIdentity);
    if (!binding || binding.tenantRef !== context.tenant.tenantRef || !sameInput(binding, input)) {
      return { kind: 'INDETERMINATE', observationRef: 'restaurant:unbound' };
    }
    try {
      const receipt = await restaurant.lookupReservation(effectIdentity);
      const exact = Object.keys(binding).every(field => receipt[field] === binding[field]);
      if (exact && receipt.status === 'reserved') return { kind: 'PRESENT', observationRef: `restaurant:${effectIdentity}` };
    } catch {}
    return { kind: 'INDETERMINATE', observationRef: 'restaurant:unavailable' };
  }

The functions above connect to your business system. The additional code below shows how your application uses AnswerUp Core to govern execution and recovery.

    submit(input) {
      const prior = admissions.get(input.requestId);
      if (prior) {
        if (!sameInput(prior.input, input)) {
          throw new Error('REQUEST_CONFLICT');
        }
        return prior.promise;
      }
      const entry = {
        tenantRef, input: structuredClone(input),
        claimPlan: structuredClone(claimPlan),
        subject: restaurant.readSlot(input.slot)?.subject,
        binding: null, promise: null,
      };
      admissions.set(input.requestId, entry);
      entry.promise = runtime.run({
        action, input,
        context: {
          ...context,
          delivery: {
            deliveryId: `delivery:${input.requestId}`,
            source: 'restaurant-lesson',
          },
          hostInvocation: {
            invocationId: `${tenantRef}:${input.requestId}`,
          },
        },
      }).then(result => ({
        result, entry, message: confirmation(result, entry),
      }));
      return entry.promise;
    },
    async reconcile(initial) {
      const result = await runtime.reconcile(
        initial.result, { claimPlan },
      );
      return {
        result, entry: initial.entry,
        message: confirmation(result, initial.entry),
      };
    },