workos 0.1.2 → 0.2.0

package/dist/src/lib/wizard-core.js

@@ -1,4 +1,6 @@
 import { setup, assign, fromPromise } from 'xstate';
+import { getManualPrInstructions } from './post-install.js';
+import { hasGhCli } from '../utils/git-utils.js';
 export const wizardMachine = setup({
     types: {
         context: {},
@@ -51,6 +53,32 @@ export const wizardMachine = setup({
         emitGitCancelled: ({ context }) => {
             context.emitter.emit('git:dirty:cancelled', {});
         },
+        emitBranchChecking: ({ context }) => {
+            context.emitter.emit('branch:checking', {});
+        },
+        emitBranchProtected: ({ context }) => {
+            if (context.currentBranch) {
+                context.emitter.emit('branch:protected', { branch: context.currentBranch });
+                context.emitter.emit('branch:prompt', { branch: context.currentBranch });
+            }
+        },
+        emitBranchCreated: ({ context }, params) => {
+            context.emitter.emit('branch:created', { branch: params.branch });
+        },
+        emitBranchCreateFailed: ({ context }) => {
+            const message = context.error?.message ?? 'Failed to create branch';
+            context.emitter.emit('branch:create:failed', { error: message });
+        },
+        assignBranchResult: assign({
+            currentBranch: ({ event }) => {
+                const doneEvent = event;
+                return doneEvent.output?.branch ?? undefined;
+            },
+            isProtectedBranch: ({ event }) => {
+                const doneEvent = event;
+                return doneEvent.output?.isProtected ?? false;
+            },
+        }),
         emitCredentialsGathering: ({ context }) => {
             const requiresApiKey = ['nextjs', 'tanstack-start', 'react-router'].includes(context.integration ?? '');
             context.emitter.emit('credentials:gathering', { requiresApiKey });
@@ -59,6 +87,44 @@ export const wizardMachine = setup({
         emitCredentialsFound: ({ context }) => {
             context.emitter.emit('credentials:found', {});
         },
+        emitEnvDetected: ({ context }) => {
+            context.emitter.emit('credentials:env:detected', { files: context.envFilesDetected ?? [] });
+        },
+        emitEnvScanPrompt: ({ context }) => {
+            context.emitter.emit('credentials:env:prompt', { files: context.envFilesDetected ?? [] });
+        },
+        emitEnvScanning: ({ context }) => {
+            context.emitter.emit('credentials:env:scanning', {});
+        },
+        emitEnvCredentialsFound: ({ context }) => {
+            context.emitter.emit('credentials:env:found', { sourcePath: context.envCredentialPath ?? '.env' });
+        },
+        emitEnvNotFound: ({ context }) => {
+            context.emitter.emit('credentials:env:notfound', {});
+        },
+        emitDeviceAuthStart: () => {
+            // Emitted by actor when it has verification URL
+        },
+        emitDeviceAuthSuccess: ({ context }) => {
+            context.emitter.emit('device:success', { email: undefined });
+        },
+        emitDeviceAuthError: ({ context }) => {
+            const message = context.error?.message ?? 'Device authorization failed';
+            context.emitter.emit('device:error', { message });
+        },
+        emitDeviceTimeout: ({ context }) => {
+            context.emitter.emit('device:timeout', {});
+        },
+        emitStagingFetching: ({ context }) => {
+            context.emitter.emit('staging:fetching', {});
+        },
+        emitStagingSuccess: ({ context }) => {
+            context.emitter.emit('staging:success', {});
+        },
+        emitStagingError: ({ context }) => {
+            const message = context.error?.message ?? 'Failed to fetch staging credentials';
+            context.emitter.emit('staging:error', { message });
+        },
         emitConfigStart: ({ context }) => {
             context.emitter.emit('config:start', {});
         },
@@ -121,12 +187,93 @@ export const wizardMachine = setup({
             context.emitter.emit('error', { message, stack: context.error?.stack });
             context.emitter.emit('complete', { success: false, summary: message });
         },
+        // Post-install actions
+        assignChangedFiles: assign({
+            changedFiles: ({ event }) => {
+                const doneEvent = event;
+                return doneEvent.output?.files ?? [];
+            },
+        }),
+        emitChangesDetected: ({ context }) => {
+            context.emitter.emit('postinstall:changes', { files: context.changedFiles ?? [] });
+        },
+        emitNoChanges: ({ context }) => {
+            context.emitter.emit('postinstall:nochanges', {});
+        },
+        emitCommitPrompt: ({ context }) => {
+            context.emitter.emit('postinstall:commit:prompt', {});
+        },
+        emitGeneratingCommitMessage: ({ context }) => {
+            context.emitter.emit('postinstall:commit:generating', {});
+        },
+        assignCommitMessage: assign({
+            commitMessage: ({ event }) => {
+                const doneEvent = event;
+                return doneEvent.output;
+            },
+        }),
+        emitCommitting: ({ context }) => {
+            context.emitter.emit('postinstall:commit:committing', { message: context.commitMessage ?? '' });
+        },
+        emitCommitSuccess: ({ context }) => {
+            context.emitter.emit('postinstall:commit:success', { message: context.commitMessage ?? '' });
+        },
+        emitCommitFailed: ({ context }) => {
+            const message = context.error?.message ?? 'Commit failed';
+            context.emitter.emit('postinstall:commit:failed', { error: message });
+        },
+        emitPrPrompt: ({ context }) => {
+            context.emitter.emit('postinstall:pr:prompt', {});
+        },
+        emitGeneratingPrDescription: ({ context }) => {
+            context.emitter.emit('postinstall:pr:generating', {});
+        },
+        assignPrDescription: assign({
+            prDescription: ({ event }) => {
+                const doneEvent = event;
+                return doneEvent.output;
+            },
+        }),
+        emitPushing: ({ context }) => {
+            context.emitter.emit('postinstall:pr:pushing', {});
+        },
+        emitPushFailed: ({ context }) => {
+            const message = context.error?.message ?? 'Push failed';
+            context.emitter.emit('postinstall:push:failed', { error: message });
+        },
+        emitCreatingPr: ({ context }) => {
+            context.emitter.emit('postinstall:pr:creating', {});
+        },
+        assignPrUrl: assign({
+            prUrl: ({ event }) => {
+                const doneEvent = event;
+                return doneEvent.output;
+            },
+        }),
+        emitPrCreated: ({ context }) => {
+            context.emitter.emit('postinstall:pr:success', { url: context.prUrl ?? '' });
+        },
+        emitPrFailed: ({ context }) => {
+            const message = context.error?.message ?? 'PR creation failed';
+            context.emitter.emit('postinstall:pr:failed', { error: message });
+        },
+        emitManualInstructions: ({ context }) => {
+            const branch = context.currentBranch ?? 'HEAD';
+            const instructions = getManualPrInstructions(branch);
+            context.emitter.emit('postinstall:manual', { instructions });
+        },
+        emitComplete: ({ context }) => {
+            const summary = context.agentSummary ?? 'WorkOS AuthKit installed successfully!';
+            context.emitter.emit('complete', { success: true, summary });
+        },
     },
     guards: {
         shouldSkipAuth: ({ context }) => context.options.skipAuth === true,
         gitIsClean: ({ context }) => context.gitIsClean === true,
         hasCredentials: ({ context }) => context.options.apiKey !== undefined && context.options.clientId !== undefined,
         hasIntegration: ({ context }) => context.integration !== undefined,
+        shouldSkipPostInstall: ({ context }) => context.options.noCommit === true,
+        hasGhCli: () => hasGhCli(),
     },
     actors: {
         checkAuthentication: fromPromise(async () => {
@@ -144,6 +291,48 @@ export const wizardMachine = setup({
         runAgent: fromPromise(async () => {
             throw new Error('runAgent not implemented - provide via machine.provide()');
         }),
+        // Credential discovery actors
+        detectEnvFiles: fromPromise(async () => {
+            throw new Error('detectEnvFiles not implemented - provide via machine.provide()');
+        }),
+        scanEnvFiles: fromPromise(async () => {
+            throw new Error('scanEnvFiles not implemented - provide via machine.provide()');
+        }),
+        checkStoredAuth: fromPromise(async () => {
+            throw new Error('checkStoredAuth not implemented - provide via machine.provide()');
+        }),
+        runDeviceAuth: fromPromise(async () => {
+            throw new Error('runDeviceAuth not implemented - provide via machine.provide()');
+        }),
+        fetchStagingCredentials: fromPromise(async () => {
+            throw new Error('fetchStagingCredentials not implemented - provide via machine.provide()');
+        }),
+        // Branch check actors
+        checkBranch: fromPromise(async () => {
+            throw new Error('checkBranch not implemented - provide via machine.provide()');
+        }),
+        createBranch: fromPromise(async () => {
+            throw new Error('createBranch not implemented - provide via machine.provide()');
+        }),
+        // Post-install actors
+        detectChanges: fromPromise(async () => {
+            throw new Error('detectChanges not implemented - provide via machine.provide()');
+        }),
+        generateCommitMessage: fromPromise(async () => {
+            throw new Error('generateCommitMessage not implemented - provide via machine.provide()');
+        }),
+        commitChanges: fromPromise(async () => {
+            throw new Error('commitChanges not implemented - provide via machine.provide()');
+        }),
+        generatePrDescription: fromPromise(async () => {
+            throw new Error('generatePrDescription not implemented - provide via machine.provide()');
+        }),
+        pushBranch: fromPromise(async () => {
+            throw new Error('pushBranch not implemented - provide via machine.provide()');
+        }),
+        createPr: fromPromise(async () => {
+            throw new Error('createPr not implemented - provide via machine.provide()');
+        }),
     },
 }).createMachine({
     id: 'wizard',
@@ -278,6 +467,73 @@ export const wizardMachine = setup({
                         },
                     },
                 },
+                branchCheck: {
+                    initial: 'running',
+                    states: {
+                        running: {
+                            entry: ['emitBranchChecking'],
+                            invoke: {
+                                id: 'checkBranch',
+                                src: 'checkBranch',
+                                onDone: [
+                                    {
+                                        target: 'awaitingConfirmation',
+                                        guard: ({ event }) => event.output.isProtected,
+                                        actions: ['assignBranchResult', 'emitBranchProtected'],
+                                    },
+                                    {
+                                        target: 'done',
+                                        actions: ['assignBranchResult'],
+                                    },
+                                ],
+                                onError: {
+                                    // Branch check failure is non-fatal
+                                    target: 'done',
+                                },
+                            },
+                        },
+                        awaitingConfirmation: {
+                            on: {
+                                BRANCH_CREATE: {
+                                    target: 'creating',
+                                },
+                                BRANCH_CONTINUE: {
+                                    target: 'done',
+                                },
+                                BRANCH_CANCEL: {
+                                    target: '#wizard.cancelled',
+                                },
+                            },
+                        },
+                        creating: {
+                            invoke: {
+                                id: 'createBranch',
+                                src: 'createBranch',
+                                input: () => ({
+                                    name: 'feat/add-workos-authkit',
+                                    fallbackName: `feat/add-workos-authkit-${Date.now()}`,
+                                }),
+                                onDone: {
+                                    target: 'done',
+                                    actions: [
+                                        {
+                                            type: 'emitBranchCreated',
+                                            params: ({ event }) => ({ branch: event.output.branch }),
+                                        },
+                                    ],
+                                },
+                                onError: {
+                                    // Branch creation failure is non-fatal
+                                    target: 'done',
+                                    actions: ['assignError', 'emitBranchCreateFailed'],
+                                },
+                            },
+                        },
+                        done: {
+                            type: 'final',
+                        },
+                    },
+                },
             },
             onDone: [
                 {
@@ -296,26 +552,194 @@ export const wizardMachine = setup({
         },
         gatheringCredentials: {
             entry: [{ type: 'emitStateEnter', params: { state: 'gatheringCredentials' } }],
-            initial: 'checking',
+            initial: 'checkingCliFlags',
             states: {
-                checking: {
+                // Step 1: Check CLI flags (highest priority)
+                checkingCliFlags: {
                     always: [
                         {
                             target: '#wizard.configuring',
                             guard: 'hasCredentials',
-                            actions: ['emitCredentialsFound', { type: 'emitStateExit', params: { state: 'gatheringCredentials' } }],
-                        },
-                        {
-                            target: 'prompting',
+                            actions: [
+                                assign({ credentialSource: () => 'cli' }),
+                                'emitCredentialsFound',
+                                { type: 'emitStateExit', params: { state: 'gatheringCredentials' } },
+                            ],
                         },
+                        { target: 'detectingEnvFiles' },
                     ],
                 },
-                prompting: {
+                // Step 2: Check if env files exist (don't read yet)
+                detectingEnvFiles: {
+                    invoke: {
+                        id: 'detectEnvFiles',
+                        src: 'detectEnvFiles',
+                        input: ({ context }) => ({ installDir: context.options.installDir }),
+                        onDone: [
+                            {
+                                target: 'promptingEnvScan',
+                                guard: ({ event }) => {
+                                    const output = event.output;
+                                    return output.exists;
+                                },
+                                actions: [
+                                    assign({
+                                        envFilesDetected: ({ event }) => {
+                                            const output = event.output;
+                                            return output.files;
+                                        },
+                                    }),
+                                    'emitEnvDetected',
+                                ],
+                            },
+                            { target: 'checkingStoredAuth' },
+                        ],
+                        onError: {
+                            target: 'checkingStoredAuth', // Non-fatal, continue
+                        },
+                    },
+                },
+                // Step 3: Ask user for consent to scan env files
+                promptingEnvScan: {
+                    entry: ['emitEnvScanPrompt'],
+                    on: {
+                        ENV_SCAN_APPROVED: {
+                            target: 'scanningEnvFiles',
+                            actions: assign({ envScanConsent: () => true }),
+                        },
+                        ENV_SCAN_DECLINED: {
+                            target: 'checkingStoredAuth',
+                            actions: assign({ envScanConsent: () => false }),
+                        },
+                        CANCEL: {
+                            target: '#wizard.cancelled',
+                            actions: { type: 'emitStateExit', params: { state: 'gatheringCredentials' } },
+                        },
+                    },
+                },
+                // Step 4: Scan env files for credentials (with consent)
+                scanningEnvFiles: {
+                    entry: ['emitEnvScanning'],
+                    invoke: {
+                        id: 'scanEnvFiles',
+                        src: 'scanEnvFiles',
+                        input: ({ context }) => ({ installDir: context.options.installDir }),
+                        onDone: [
+                            {
+                                target: '#wizard.configuring',
+                                guard: ({ event }) => {
+                                    const result = event.output;
+                                    return result.found && !!result.clientId;
+                                },
+                                actions: [
+                                    assign({
+                                        credentials: ({ event }) => {
+                                            const result = event.output;
+                                            return { clientId: result.clientId, apiKey: result.apiKey };
+                                        },
+                                        credentialSource: () => 'env',
+                                        envCredentialPath: ({ event }) => event.output.sourcePath,
+                                    }),
+                                    'emitEnvCredentialsFound',
+                                    { type: 'emitStateExit', params: { state: 'gatheringCredentials' } },
+                                ],
+                            },
+                            {
+                                target: 'checkingStoredAuth',
+                                actions: ['emitEnvNotFound'],
+                            },
+                        ],
+                        onError: {
+                            target: 'checkingStoredAuth',
+                        },
+                    },
+                },
+                // Step 5: Check for stored auth token
+                checkingStoredAuth: {
+                    invoke: {
+                        id: 'checkStoredAuth',
+                        src: 'checkStoredAuth',
+                        onDone: [
+                            {
+                                target: 'fetchingStagingCredentials',
+                                guard: ({ event }) => event.output === true,
+                            },
+                            { target: 'runningDeviceAuth' },
+                        ],
+                        onError: {
+                            target: 'runningDeviceAuth',
+                        },
+                    },
+                },
+                // Step 6: Run device authorization flow
+                runningDeviceAuth: {
+                    entry: ['emitDeviceAuthStart'],
+                    invoke: {
+                        id: 'runDeviceAuth',
+                        src: 'runDeviceAuth',
+                        input: ({ context }) => ({ emitter: context.emitter }),
+                        onDone: {
+                            target: 'fetchingStagingCredentials',
+                            actions: [
+                                'emitDeviceAuthSuccess',
+                                assign({
+                                    deviceAuth: ({ event }) => {
+                                        const output = event.output;
+                                        return {
+                                            verificationUri: output.deviceAuth.verification_uri,
+                                            verificationUriComplete: output.deviceAuth.verification_uri_complete,
+                                            userCode: output.deviceAuth.user_code,
+                                        };
+                                    },
+                                }),
+                            ],
+                        },
+                        onError: {
+                            target: 'promptingManual',
+                            actions: ['assignError', 'emitDeviceAuthError'],
+                        },
+                    },
+                },
+                // Step 7: Fetch staging credentials from API
+                fetchingStagingCredentials: {
+                    entry: ['emitStagingFetching'],
+                    invoke: {
+                        id: 'fetchStagingCredentials',
+                        src: 'fetchStagingCredentials',
+                        onDone: {
+                            target: '#wizard.configuring',
+                            actions: [
+                                assign({
+                                    credentials: ({ event }) => {
+                                        const staging = event.output;
+                                        return { clientId: staging.clientId, apiKey: staging.apiKey };
+                                    },
+                                    credentialSource: ({ context }) => context.deviceAuth ? 'device' : 'stored',
+                                }),
+                                'emitStagingSuccess',
+                                { type: 'emitStateExit', params: { state: 'gatheringCredentials' } },
+                            ],
+                        },
+                        onError: {
+                            target: 'promptingManual',
+                            actions: ['assignError', 'emitStagingError'],
+                        },
+                    },
+                },
+                // Step 8: Manual fallback
+                promptingManual: {
                     entry: ['emitCredentialsGathering'],
                     on: {
                         CREDENTIALS_SUBMITTED: {
                             target: '#wizard.configuring',
-                            actions: ['assignCredentials', { type: 'emitStateExit', params: { state: 'gatheringCredentials' } }],
+                            actions: [
+                                'assignCredentials',
+                                assign({ credentialSource: () => 'manual' }),
+                                { type: 'emitStateExit', params: { state: 'gatheringCredentials' } },
+                            ],
+                        },
+                        RETRY_AUTH: {
+                            target: 'runningDeviceAuth',
                         },
                         CANCEL: {
                             target: '#wizard.cancelled',
@@ -347,37 +771,208 @@ export const wizardMachine = setup({
                 id: 'runAgent',
                 src: 'runAgent',
                 input: ({ context }) => ({ context }),
-                onDone: {
-                    target: 'complete',
-                    actions: [
-                        ({ context, event }) => {
+                onDone: [
+                    {
+                        target: 'error',
+                        guard: ({ event }) => {
                             const output = event.output;
-                            if (output.success) {
-                                context.emitter.emit('agent:success', { summary: output.summary });
-                                context.emitter.emit('complete', { success: true, summary: output.summary });
-                            }
-                            else {
+                            return !output.success;
+                        },
+                        actions: [
+                            ({ context, event }) => {
+                                const output = event.output;
                                 context.emitter.emit('agent:failure', {
                                     message: output.error?.message ?? 'Agent failed',
                                 });
-                                context.emitter.emit('complete', {
-                                    success: false,
-                                    summary: output.error?.message,
-                                });
-                            }
-                        },
-                        { type: 'emitStateExit', params: { state: 'runningAgent' } },
-                    ],
-                },
+                            },
+                            assign({
+                                error: ({ event }) => {
+                                    const output = event.output;
+                                    return output.error ?? new Error('Agent failed');
+                                },
+                            }),
+                            { type: 'emitStateExit', params: { state: 'runningAgent' } },
+                        ],
+                    },
+                    {
+                        target: 'postInstall',
+                        actions: [
+                            assign({
+                                agentSummary: ({ event }) => {
+                                    const output = event.output;
+                                    return output.summary;
+                                },
+                            }),
+                            ({ context, event }) => {
+                                const output = event.output;
+                                context.emitter.emit('agent:success', { summary: output.summary });
+                            },
+                            { type: 'emitStateExit', params: { state: 'runningAgent' } },
+                        ],
+                    },
+                ],
                 onError: {
                     target: 'error',
                     actions: ['assignError', 'emitAgentFailure', { type: 'emitStateExit', params: { state: 'runningAgent' } }],
                 },
             },
         },
+        postInstall: {
+            initial: 'checking',
+            entry: [{ type: 'emitStateEnter', params: { state: 'postInstall' } }],
+            states: {
+                checking: {
+                    always: [
+                        {
+                            target: '#wizard.complete',
+                            guard: 'shouldSkipPostInstall',
+                        },
+                        { target: 'detectingChanges' },
+                    ],
+                },
+                detectingChanges: {
+                    invoke: {
+                        id: 'detectChanges',
+                        src: 'detectChanges',
+                        onDone: [
+                            {
+                                target: 'promptingCommit',
+                                guard: ({ event }) => event.output.hasChanges,
+                                actions: ['assignChangedFiles', 'emitChangesDetected'],
+                            },
+                            {
+                                target: 'done',
+                                actions: ['emitNoChanges'],
+                            },
+                        ],
+                        onError: { target: 'done' },
+                    },
+                },
+                promptingCommit: {
+                    entry: ['emitCommitPrompt'],
+                    on: {
+                        COMMIT_APPROVED: { target: 'generatingCommitMessage' },
+                        COMMIT_DECLINED: { target: 'done' },
+                        CANCEL: { target: '#wizard.cancelled' },
+                    },
+                },
+                generatingCommitMessage: {
+                    entry: ['emitGeneratingCommitMessage'],
+                    invoke: {
+                        id: 'generateCommitMessage',
+                        src: 'generateCommitMessage',
+                        input: ({ context }) => ({
+                            integration: context.integration ?? 'project',
+                            files: context.changedFiles ?? [],
+                        }),
+                        onDone: {
+                            target: 'committing',
+                            actions: ['assignCommitMessage'],
+                        },
+                    },
+                },
+                committing: {
+                    entry: ['emitCommitting'],
+                    invoke: {
+                        id: 'commitChanges',
+                        src: 'commitChanges',
+                        input: ({ context }) => ({
+                            message: context.commitMessage ?? '',
+                            cwd: context.options.installDir,
+                        }),
+                        onDone: {
+                            target: 'checkingGhCli',
+                            actions: ['emitCommitSuccess'],
+                        },
+                        onError: {
+                            target: 'done',
+                            actions: ['assignError', 'emitCommitFailed'],
+                        },
+                    },
+                },
+                checkingGhCli: {
+                    always: [
+                        {
+                            target: 'promptingPr',
+                            guard: 'hasGhCli',
+                        },
+                        {
+                            target: 'showingManualInstructions',
+                        },
+                    ],
+                },
+                promptingPr: {
+                    entry: ['emitPrPrompt'],
+                    on: {
+                        PR_APPROVED: { target: 'generatingPrDescription' },
+                        PR_DECLINED: { target: 'done' },
+                        CANCEL: { target: '#wizard.cancelled' },
+                    },
+                },
+                generatingPrDescription: {
+                    entry: ['emitGeneratingPrDescription'],
+                    invoke: {
+                        id: 'generatePrDescription',
+                        src: 'generatePrDescription',
+                        input: ({ context }) => ({
+                            integration: context.integration ?? 'project',
+                            files: context.changedFiles ?? [],
+                            commitMessage: context.commitMessage ?? '',
+                        }),
+                        onDone: {
+                            target: 'pushing',
+                            actions: ['assignPrDescription'],
+                        },
+                    },
+                },
+                pushing: {
+                    entry: ['emitPushing'],
+                    invoke: {
+                        id: 'pushBranch',
+                        src: 'pushBranch',
+                        input: ({ context }) => ({ cwd: context.options.installDir }),
+                        onDone: { target: 'creatingPr' },
+                        onError: {
+                            target: 'showingManualInstructions',
+                            actions: ['assignError', 'emitPushFailed'],
+                        },
+                    },
+                },
+                creatingPr: {
+                    entry: ['emitCreatingPr'],
+                    invoke: {
+                        id: 'createPr',
+                        src: 'createPr',
+                        input: ({ context }) => ({
+                            title: context.commitMessage ?? '',
+                            body: context.prDescription ?? '',
+                            cwd: context.options.installDir,
+                        }),
+                        onDone: {
+                            target: 'done',
+                            actions: ['assignPrUrl', 'emitPrCreated'],
+                        },
+                        onError: {
+                            target: 'done',
+                            actions: ['assignError', 'emitPrFailed'],
+                        },
+                    },
+                },
+                showingManualInstructions: {
+                    entry: ['emitManualInstructions'],
+                    always: { target: 'done' },
+                },
+                done: {
+                    type: 'final',
+                },
+            },
+            onDone: {
+                target: 'complete',
+            },
+        },
         complete: {
             type: 'final',
-            entry: { type: 'emitStateEnter', params: { state: 'complete' } },
+            entry: [{ type: 'emitStateEnter', params: { state: 'complete' } }, 'emitComplete'],
         },
         cancelled: {
             type: 'final',