@shipfox/api-workflows 2.0.0

package/src/presentation/routes/report-step.test.ts

@@ -0,0 +1,374 @@
+import {createLeaseTokenAuthMethod} from '@shipfox/api-auth';
+import {closeApp, createApp, type FastifyInstance} from '@shipfox/node-fastify';
+import {nextStepForJob} from '#core/job-execution.js';
+import {
+  getFirstJobExecutionByJobId,
+  getJobById,
+  getStepAttempts,
+  getStepsByJobId,
+  getWorkflowRunByAttemptId,
+} from '#db/workflow-runs.js';
+import {insertRunningJobLease, mintActiveLeaseToken} from '#test/fixtures/active-lease-token.js';
+import {arrangeJobWithSteps} from '#test/fixtures/job-with-steps.js';
+import {mintLeaseToken} from '#test/fixtures/lease-token.js';
+import {leaseTokenRouteGroup} from './index.js';
+
+function reportUrl(stepId: string): string {
+  return `/runs/jobs/current/steps/${stepId}/report`;
+}
+
+function reportPayload(payload: Record<string, unknown>): Record<string, unknown> {
+  return {...payload, log_outcome: 'drained'};
+}
+
+describe('POST /runs/jobs/current/steps/:stepId/report', () => {
+  let app: FastifyInstance;
+
+  beforeAll(async () => {
+    app = await createApp({
+      auth: [createLeaseTokenAuthMethod()],
+      routes: [leaseTokenRouteGroup],
+      swagger: false,
+    });
+    await app.ready();
+  });
+
+  afterAll(async () => {
+    await closeApp();
+  });
+
+  test('rejects a request without a lease token', async () => {
+    const res = await app.inject({
+      method: 'POST',
+      url: reportUrl(crypto.randomUUID()),
+      payload: reportPayload({status: 'succeeded'}),
+    });
+
+    expect(res.statusCode).toBe(401);
+    expect(res.json().code).toBe('unauthorized');
+  });
+
+  test('returns 404 when the lease token is no longer the active job lease', async () => {
+    const {jobId, steps} = await arrangeJobWithSteps(1);
+    await nextStepForJob(jobId);
+    const jobExecution = await getFirstJobExecutionByJobId(jobId);
+    if (!jobExecution) throw new Error('Expected job execution to exist');
+    const job = await getJobById(jobId);
+    if (!job) throw new Error('Expected job to exist');
+    const run = await getWorkflowRunByAttemptId(job.workflowRunAttemptId);
+    if (!run) throw new Error('Expected workflow run to exist');
+    await insertRunningJobLease({
+      workspaceId: run.workspaceId,
+      workflowRunId: run.id,
+      workflowRunAttemptId: job.workflowRunAttemptId,
+      jobId,
+      jobExecutionId: jobExecution.id,
+      projectId: run.projectId,
+      runnerSessionId: crypto.randomUUID(),
+    });
+    const token = await mintLeaseToken({
+      jobId,
+      jobExecutionId: jobExecution.id,
+      workflowRunId: run.id,
+      workflowRunAttemptId: job.workflowRunAttemptId,
+      projectId: run.projectId,
+      workspaceId: run.workspaceId,
+      runnerSessionId: crypto.randomUUID(),
+    });
+
+    const res = await app.inject({
+      method: 'POST',
+      url: reportUrl(steps[0]?.id as string),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({status: 'succeeded'}),
+    });
+
+    expect(res.statusCode).toBe(404);
+    expect(res.json().code).toBe('lease-not-active');
+  });
+
+  test('records a succeeded mid-job step → {ok, cancel:false}', async () => {
+    const {jobId, steps} = await arrangeJobWithSteps(2);
+    const token = await mintActiveLeaseToken({jobId});
+    await nextStepForJob(jobId);
+
+    const res = await app.inject({
+      method: 'POST',
+      url: reportUrl(steps[0]?.id as string),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({status: 'succeeded'}),
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toEqual({ok: true, cancel: false});
+    expect((await getStepsByJobId(jobId))[0]?.status).toBe('succeeded');
+  });
+
+  test('finishing the job fully succeeded → {ok, cancel:false}', async () => {
+    const {jobId, steps} = await arrangeJobWithSteps(1);
+    const token = await mintActiveLeaseToken({jobId});
+    await nextStepForJob(jobId);
+
+    const res = await app.inject({
+      method: 'POST',
+      url: reportUrl(steps[0]?.id as string),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({status: 'succeeded'}),
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toEqual({ok: true, cancel: false});
+  });
+
+  test('a failed final report finishes the job → {ok, cancel:true}', async () => {
+    const {jobId, steps} = await arrangeJobWithSteps(1);
+    const token = await mintActiveLeaseToken({jobId});
+    await nextStepForJob(jobId);
+
+    const res = await app.inject({
+      method: 'POST',
+      url: reportUrl(steps[0]?.id as string),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({status: 'failed', error: {message: 'boom'}}),
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toEqual({ok: true, cancel: true});
+  });
+
+  test('a failed report leaves remaining steps dispatchable → {ok, cancel:false}', async () => {
+    const {jobId, steps} = await arrangeJobWithSteps(3);
+    const token = await mintActiveLeaseToken({jobId});
+    await nextStepForJob(jobId);
+
+    const res = await app.inject({
+      method: 'POST',
+      url: reportUrl(steps[0]?.id as string),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({status: 'failed', error: {message: 'boom'}}),
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toEqual({ok: true, cancel: false});
+    const after = await getStepsByJobId(jobId);
+    expect(after[0]?.status).toBe('failed');
+    expect(after[1]?.status).toBe('pending');
+    expect(after[2]?.status).toBe('pending');
+  });
+
+  test('persists the wire error snake_case fields as camelCase on the step row', async () => {
+    const {jobId, steps} = await arrangeJobWithSteps(2);
+    const token = await mintActiveLeaseToken({jobId});
+    await nextStepForJob(jobId);
+
+    const res = await app.inject({
+      method: 'POST',
+      url: reportUrl(steps[0]?.id as string),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({
+        status: 'failed',
+        error: {message: 'boom', exit_code: 1, signal: 'SIGKILL'},
+      }),
+    });
+
+    expect(res.statusCode).toBe(200);
+    const after = await getStepsByJobId(jobId);
+    expect(after[0]?.error).toEqual({message: 'boom', exitCode: 1, signal: 'SIGKILL'});
+    const [attempt] = await getStepAttempts(jobId);
+    expect(attempt?.exitCode).toBe(1);
+  });
+
+  test('persists structured output on the attempt row', async () => {
+    const {jobId, steps} = await arrangeJobWithSteps(1);
+    const token = await mintActiveLeaseToken({jobId});
+    await nextStepForJob(jobId);
+
+    const res = await app.inject({
+      method: 'POST',
+      url: reportUrl(steps[0]?.id as string),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({
+        status: 'succeeded',
+        output: {artifact: 'dist/app.tgz'},
+        exit_code: 0,
+      }),
+    });
+
+    expect(res.statusCode).toBe(200);
+    const [attempt] = await getStepAttempts(jobId);
+    expect(attempt?.output).toEqual({artifact: 'dist/app.tgz'});
+    expect(attempt?.exitCode).toBe(0);
+  });
+
+  test('rejects a failed report without an error', async () => {
+    const {jobId, steps} = await arrangeJobWithSteps(1);
+    const token = await mintActiveLeaseToken({jobId});
+    await nextStepForJob(jobId);
+
+    const res = await app.inject({
+      method: 'POST',
+      url: reportUrl(steps[0]?.id as string),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({status: 'failed'}),
+    });
+
+    expect(res.statusCode).toBe(400);
+    expect(res.json().code).toBe('validation-error');
+  });
+
+  test('rejects a succeeded report with an error', async () => {
+    const {jobId, steps} = await arrangeJobWithSteps(1);
+    const token = await mintActiveLeaseToken({jobId});
+    await nextStepForJob(jobId);
+
+    const res = await app.inject({
+      method: 'POST',
+      url: reportUrl(steps[0]?.id as string),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({status: 'succeeded', error: {message: 'should not be here'}}),
+    });
+
+    expect(res.statusCode).toBe(400);
+    expect(res.json().code).toBe('validation-error');
+  });
+
+  test('a duplicate succeeded report is a no-op with the same response', async () => {
+    const {jobId, steps} = await arrangeJobWithSteps(2);
+    const token = await mintActiveLeaseToken({jobId});
+    await nextStepForJob(jobId);
+    const first = await app.inject({
+      method: 'POST',
+      url: reportUrl(steps[0]?.id as string),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({status: 'succeeded'}),
+    });
+
+    const second = await app.inject({
+      method: 'POST',
+      url: reportUrl(steps[0]?.id as string),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({status: 'succeeded'}),
+    });
+
+    expect(first.statusCode).toBe(200);
+    expect(second.statusCode).toBe(200);
+    expect(second.json()).toEqual(first.json());
+    const after = await getStepsByJobId(jobId);
+    expect(after[0]?.status).toBe('succeeded');
+    expect(after[1]?.status).toBe('pending');
+  });
+
+  test('a late succeeded report after failure completion never downgrades and says cancel', async () => {
+    const {jobId, steps} = await arrangeJobWithSteps(2);
+    const token = await mintActiveLeaseToken({jobId});
+    await nextStepForJob(jobId);
+    await app.inject({
+      method: 'POST',
+      url: reportUrl(steps[0]?.id as string),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({status: 'failed', error: {message: 'boom'}}),
+    });
+    await nextStepForJob(jobId);
+
+    const res = await app.inject({
+      method: 'POST',
+      url: reportUrl(steps[0]?.id as string),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({status: 'succeeded'}),
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toEqual({ok: true, cancel: true});
+    const after = await getStepsByJobId(jobId);
+    expect(after[0]?.status).toBe('failed');
+    expect(after[1]?.status).toBe('skipped');
+  });
+
+  test('rejects a result for a pending (never-dispatched) step with 409', async () => {
+    const {jobId, steps} = await arrangeJobWithSteps(2);
+    const token = await mintActiveLeaseToken({jobId});
+
+    const res = await app.inject({
+      method: 'POST',
+      url: reportUrl(steps[0]?.id as string),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({status: 'succeeded'}),
+    });
+
+    expect(res.statusCode).toBe(409);
+    expect(res.json().code).toBe('step-not-running');
+  });
+
+  test('rejects an unknown stepId with 404', async () => {
+    const {jobId} = await arrangeJobWithSteps(1);
+    const token = await mintActiveLeaseToken({jobId});
+
+    const res = await app.inject({
+      method: 'POST',
+      url: reportUrl(crypto.randomUUID()),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({status: 'succeeded'}),
+    });
+
+    expect(res.statusCode).toBe(404);
+    expect(res.json().code).toBe('step-not-found');
+  });
+
+  test("rejects another job's stepId with 404", async () => {
+    const a = await arrangeJobWithSteps(1);
+    const b = await arrangeJobWithSteps(1);
+    const token = await mintActiveLeaseToken({jobId: a.jobId});
+    await nextStepForJob(b.jobId);
+
+    const res = await app.inject({
+      method: 'POST',
+      url: reportUrl(b.steps[0]?.id as string),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({status: 'succeeded'}),
+    });
+
+    expect(res.statusCode).toBe(404);
+    expect(res.json().code).toBe('step-not-found');
+  });
+
+  test('concurrent duplicate reports all succeed and land one result', async () => {
+    const {jobId, steps} = await arrangeJobWithSteps(2);
+    const token = await mintActiveLeaseToken({jobId});
+    await nextStepForJob(jobId);
+
+    const responses = await Promise.all(
+      Array.from({length: 5}, () =>
+        app.inject({
+          method: 'POST',
+          url: reportUrl(steps[0]?.id as string),
+          headers: {authorization: `Bearer ${token}`},
+          payload: reportPayload({status: 'succeeded'}),
+        }),
+      ),
+    );
+
+    for (const res of responses) {
+      expect(res.statusCode).toBe(200);
+      expect(res.json()).toEqual({ok: true, cancel: false});
+    }
+    const after = await getStepsByJobId(jobId);
+    expect(after[0]?.status).toBe('succeeded');
+    expect(after[1]?.status).toBe('pending');
+  });
+
+  test('a report whose attempt is ahead of the current attempt → 409 step-attempt-ahead', async () => {
+    const {jobId, steps} = await arrangeJobWithSteps(1);
+    const token = await mintActiveLeaseToken({jobId});
+    await nextStepForJob(jobId);
+
+    const res = await app.inject({
+      method: 'POST',
+      url: reportUrl(steps[0]?.id as string),
+      headers: {authorization: `Bearer ${token}`},
+      payload: reportPayload({status: 'succeeded', attempt: 2}),
+    });
+
+    expect(res.statusCode).toBe(409);
+    expect(res.json().code).toBe('step-attempt-ahead');
+  });
+});

package/src/presentation/routes/report-step.ts

@@ -0,0 +1,61 @@
+import {requireLeasedJobContext} from '@shipfox/api-auth-context';
+import {isJobLeaseActive} from '@shipfox/api-runners';
+import {reportStepBodySchema, reportStepResponseSchema} from '@shipfox/api-workflows-dto';
+import {ClientError, defineRoute} from '@shipfox/node-fastify';
+import {z} from 'zod';
+import {StepAttemptAheadError, StepNotFoundError, StepNotRunningError} from '#core/errors.js';
+import {recordStepResult} from '#core/job-execution.js';
+import {fromStepErrorDto} from '#presentation/dto/step.js';
+
+export const reportStepRoute = defineRoute({
+  method: 'POST',
+  path: '/steps/:stepId/report',
+  description:
+    'Reports whether a step succeeded or failed. The job is identified by the access token. Reporting the same step more than once is safe: once a step has finished, later reports for it are ignored. The runner does not call a separate job-completion endpoint — finalization is driven server-side from the recorded step results, and the `cancel` flag tells the runner to stop once the job has finished without full success.',
+  schema: {
+    params: z.object({stepId: z.string().uuid()}),
+    body: reportStepBodySchema,
+    response: {
+      200: reportStepResponseSchema,
+    },
+  },
+  errorHandler: (error) => {
+    if (error instanceof StepNotFoundError) {
+      throw new ClientError(error.message, 'step-not-found', {status: 404});
+    }
+    if (error instanceof StepNotRunningError) {
+      throw new ClientError(error.message, 'step-not-running', {status: 409});
+    }
+    if (error instanceof StepAttemptAheadError) {
+      throw new ClientError(error.message, 'step-attempt-ahead', {status: 409});
+    }
+    throw error;
+  },
+  handler: async (request) => {
+    const {stepId} = request.params;
+    const leasedJob = requireLeasedJobContext(request);
+
+    const leaseIsActive = await isJobLeaseActive({
+      jobId: leasedJob.jobId,
+      jobExecutionId: leasedJob.jobExecutionId,
+      runnerSessionId: leasedJob.runnerSessionId,
+    });
+    if (!leaseIsActive) {
+      throw new ClientError('Job lease is no longer active', 'lease-not-active', {status: 404});
+    }
+
+    const outcome = await recordStepResult({
+      jobExecutionId: leasedJob.jobExecutionId,
+      stepId,
+      status: request.body.status,
+      error: fromStepErrorDto(request.body.error),
+      output: request.body.output ?? null,
+      response: request.body.response ?? null,
+      exitCode: request.body.exit_code ?? request.body.error?.exit_code ?? null,
+      logOutcome: request.body.log_outcome,
+      ...(request.body.attempt !== undefined ? {attempt: request.body.attempt} : {}),
+    });
+
+    return {ok: true, cancel: outcome.jobFinished && outcome.status === 'failed'};
+  },
+});

package/src/presentation/routes/require-accessible-run.ts

@@ -0,0 +1,27 @@
+import {requireProjectAccess} from '@shipfox/api-projects';
+import {ClientError} from '@shipfox/node-fastify';
+import type {FastifyRequest} from 'fastify';
+import type {WorkflowRun} from '#core/entities/workflow-run.js';
+import {getWorkflowRunById} from '#db/index.js';
+
+export async function requireAccessibleRun({
+  request,
+  id,
+}: {
+  request: FastifyRequest;
+  id: string;
+}): Promise<WorkflowRun> {
+  const run = await getWorkflowRunById(id);
+  if (!run) {
+    throw new ClientError('Run not found', 'not-found', {status: 404});
+  }
+
+  await requireProjectAccess({request, projectId: run.projectId}).catch((err: unknown) => {
+    if (err instanceof ClientError && (err.status === 403 || err.status === 404)) {
+      throw new ClientError('Run not found', 'not-found', {status: 404});
+    }
+    throw err;
+  });
+
+  return run;
+}

package/src/presentation/routes/rerun-run.test.ts

@@ -0,0 +1,202 @@
+import {buildUserContext, setUserContext} from '@shipfox/api-auth-context';
+import {requireProjectAccess} from '@shipfox/api-projects';
+import {ClientError} from '@shipfox/node-fastify';
+import type {FastifyInstance} from 'fastify';
+import Fastify from 'fastify';
+import {serializerCompiler, validatorCompiler} from 'fastify-type-provider-zod';
+import {
+  createWorkflowRun,
+  getJobsByWorkflowRunId,
+  updateJobStatus,
+  updateWorkflowRunStatus,
+} from '#db/workflow-runs.js';
+import {workflowModel} from '#test/index.js';
+import {rerunRunRoute} from './rerun-run.js';
+
+const projectAccessState = vi.hoisted(() => ({workspaceId: ''}));
+
+vi.mock('@shipfox/api-projects', () => ({
+  requireProjectAccess: vi.fn(({projectId}) =>
+    Promise.resolve({
+      project: {id: projectId, workspaceId: projectAccessState.workspaceId},
+      workspaceId: projectAccessState.workspaceId,
+    }),
+  ),
+}));
+
+const mockRequireProjectAccess = vi.mocked(requireProjectAccess);
+
+describe('POST /api/workflows/runs/:id/rerun', () => {
+  let app: FastifyInstance;
+  let workspaceId: string;
+  let projectId: string;
+
+  beforeAll(async () => {
+    app = Fastify();
+    app.setValidatorCompiler(validatorCompiler);
+    app.setSerializerCompiler(serializerCompiler);
+    app.addHook('onRequest', (request, _reply, done) => {
+      setUserContext(
+        request,
+        buildUserContext({
+          userId: crypto.randomUUID(),
+          email: 'user@example.com',
+          memberships: [{workspaceId, role: 'admin'}],
+        }),
+      );
+      done();
+    });
+    app.post('/api/workflows/runs/:id/rerun', rerunRunRoute);
+    await app.ready();
+  });
+
+  beforeEach(() => {
+    workspaceId = crypto.randomUUID();
+    projectId = crypto.randomUUID();
+    projectAccessState.workspaceId = workspaceId;
+    mockRequireProjectAccess.mockImplementation(({projectId: requestedProjectId}) =>
+      Promise.resolve({
+        project: {
+          id: requestedProjectId,
+          workspaceId,
+          sourceConnectionId: crypto.randomUUID(),
+          sourceExternalRepositoryId: `repo:${crypto.randomUUID()}`,
+          name: 'Project',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        workspaceId,
+      }),
+    );
+  });
+
+  async function createTerminalRun(status: 'succeeded' | 'failed' = 'failed') {
+    const run = await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId: crypto.randomUUID(),
+      model: workflowModel({jobs: {build: {steps: [{run: 'echo build'}]}}}),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+    return updateWorkflowRunStatus({workflowRunId: run.id, status, expectedVersion: run.version});
+  }
+
+  async function createFailedRunWithFailedJob() {
+    const run = await createTerminalRun('failed');
+    const [job] = await getJobsByWorkflowRunId(run.id);
+    if (!job) throw new Error('Expected workflow job');
+    await updateJobStatus({jobId: job.id, status: 'failed', expectedVersion: job.version});
+    return run;
+  }
+
+  test('creates a new attempt for all mode', async () => {
+    const source = await createTerminalRun('failed');
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/api/workflows/runs/${source.id}/rerun`,
+      payload: {mode: 'all'},
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toMatchObject({
+      id: source.id,
+      current_attempt: 2,
+      latest_attempt: 2,
+      status: 'pending',
+    });
+  });
+
+  test('creates a new attempt for failed mode', async () => {
+    const source = await createFailedRunWithFailedJob();
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/api/workflows/runs/${source.id}/rerun`,
+      payload: {mode: 'failed'},
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toMatchObject({
+      id: source.id,
+      current_attempt: 2,
+      latest_attempt: 2,
+      status: 'pending',
+    });
+  });
+
+  test('returns 409 when failed mode has no failed or cancelled jobs', async () => {
+    const source = await createTerminalRun('succeeded');
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/api/workflows/runs/${source.id}/rerun`,
+      payload: {mode: 'failed'},
+    });
+
+    expect(res.statusCode).toBe(409);
+    expect(res.json().code).toBe('no-failed-jobs');
+  });
+
+  test('returns 409 when the source run is not terminal', async () => {
+    const source = await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId: crypto.randomUUID(),
+      model: workflowModel(),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/api/workflows/runs/${source.id}/rerun`,
+      payload: {mode: 'all'},
+    });
+
+    expect(res.statusCode).toBe(409);
+    expect(res.json().code).toBe('run-not-terminal');
+  });
+
+  test('returns 404 for a missing or inaccessible source run', async () => {
+    const missing = await app.inject({
+      method: 'POST',
+      url: `/api/workflows/runs/${crypto.randomUUID()}/rerun`,
+      payload: {mode: 'all'},
+    });
+    const source = await createTerminalRun('failed');
+    mockRequireProjectAccess.mockRejectedValueOnce(
+      new ClientError('Forbidden', 'forbidden', {status: 403}),
+    );
+
+    const inaccessible = await app.inject({
+      method: 'POST',
+      url: `/api/workflows/runs/${source.id}/rerun`,
+      payload: {mode: 'all'},
+    });
+
+    expect(missing.statusCode).toBe(404);
+    expect(inaccessible.statusCode).toBe(404);
+  });
+
+  test('returns 400 for an invalid mode', async () => {
+    const source = await createTerminalRun('failed');
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/api/workflows/runs/${source.id}/rerun`,
+      payload: {mode: 'everything'},
+    });
+
+    expect(res.statusCode).toBe(400);
+  });
+});