export const UploadDocumentFromUrlAction = {
    // This is simplification, but tells that the action should be exposed under that url
    httpTrigger: '/documents/upload-from-url',
    inputSchema: UploadDocumentFromUrlActionSchema
    handler: async (input: UploadDocumentFromUrlActionInput, { createDocumentCommand }) => {
        const {url} = input
       const file = await downloadFile(url)
       const { key } = await uploadFileToBucket(file)
       const documentId = generateId()
       const result = await createDocumentHandler({
            // Commands are always applied to 1 instance and need the Id
            aggregateId: documentId,
            payload: {
                key
            }
       })
       return result
    },
}

import { documentCreatedEvent } from './document-created-event'
/**
 * Castore uses Classes, I am not sure if I like classes, but just using one here to show
 * that there can be additional different logic (e.g. ZodCommand vs Command)
 * Maybe having this customizability makes more sense in middleware, but not sure.
 */
export const CreateDocumentCommand = new ZodCommand({
    payloadSchema: CreateCommandPayloadSchema
    handler: async (input: CreateCommandInput, documentStore: DocumentEventStore) => {
        /**
         * The input is already validated by the ZodCommand class.
         * But we could also validate here against the state of the current "Documen"
         * This does not make sense in a "create" scenario though.
         */
        const { aggregateId, payload} = command
        const{ key } = payload
        const event: DocumentCreatedEventDetails = {
            aggregateId,
            version: 1,
            type: documentCreatedEventType.type,
            payload: documentCreatedEventType.payloadSchema.parse({ key }),
        }
        await documentEventStore.pushEvent(event)

        return { documentId:aggregateId }
    }
})

//Again custore use a class (I think for type inference)
const documentCreatedEvent = new ZodEventType({
    type: 'DOCUMENTS:DOCUMENT_CREATED',
    payloadSchema: documentCreatedPayloadSchema,
})
export type DocumentCreatedEventDetails = EventDetails<typeof documentCreatedEvent>

export const documentReducer: Reducer<DocumentAggregate, DocumentEventDetails> = (
    documentAggregate,
    newEvent: DocumentEventDetails
) => {
    const { aggregateId, version, timestamp } = newEvent

    switch (newEvent.type) {
        case 'DOCUMENTS:DOCUMENT_CREATED': {
            const { name, key } = newEvent.payload
            return {
                aggregateId,
                version,
                name,
                key,
                createdAt: timestamp,
                status: 'CREATED',
            }
        }

        default:
            return documentAggregate
    }
}

const analyzeDocumentOnCreationAction = {
    /**
     * This is just declerative, this might be connected in the background in memory,
     * or on different services via a queue, that retries if things fail etc...
     */
    eventTrigger: documentCreatedEventType.type,
    handler: async (event: DocumentCreatedEventDetails, { run,get,/*createExpenseCommand, fileStorage*/ }) => {
        const {
            aggregateId,
            payload: { key },
        } = event

        // const file = await downloadFileFromBucket(key)
        const file = await fileStorage.get(key)
        const aiResult = await analyzeDocumentWithAi(file)

        const fileStorage = get(FileStorage)
        const result = run(CreateDocumentCommand, {...})


        if (aiResult.isExpense) {
            const result = await createExpenseCommand({
                aggregateId,
                payload: {
                    amount: aiResult.amount,
                    currency: aiResult.currency,
                    date: aiResult.date,
                    vendor: aiResult.vendor,
                },
            })
            return result
        }
    },
}

import {salesforce} from '@talix/trigger

import { createUserCommand } from 'domain/document
import {fileStorage} from 'domain/file-storage'

const onEmailSignup = new Action<>({
    on: salesforce.on("Lead.Created")
    handler: async (event, { run, getService }) => {
        const { email } = event
        const upload = await run(fileStorage.put, {

        })
        const fs = getService(fileStorage)
        const result = await run(createUserCommand, {
            email
        })


        return result
    }
    handler: async (event, { documentService }) => {
        const { email } = event
        const result = await createUser({
            email
        })
        return result
    }
})


const onEmailSignup = {
    on: emailSignupEvent.type
    handler: async (event, { run }) => {
        const user = run(GetUserQuery, event.user.id)
        await sendSlackNotification(event.user.firstName)
    }
}

import {...} from 'domain/document
// app/cf-api

export const documentService = app.createService({
    name: 'document',
    actions: {
        uploadDocumentFromUrl: uploadDocumentFromUrlAction,
        analyzeDocumentOnCreation: analyzeDocumentOnCreationAction,
    },
    commands: {
        createDocument: createDocumentCommand,
    },
    events: {
        documentCreated: documentCreatedEvent,
    },
    queries: {
        getDocument: getDocumentQuery,
    },
    reducers: {
        document: documentReducer,
    },
})

// docmain/document
export const documentService = {
    action: {

    }
    commands: {
         createDcoument: createDocumentCommand
    },
    events: Record<string, Event>
    queries: Record<string, Query>
    projections: Record<string, Projections>
}

const runtime = cloudflareRuntime.use(
    orchidReporter()
)
.register(new CloudflareFileStorage())
.register(new IdGenerator())
.create()


function create(){
    const context = {
        get fileStorage(): {
            ....
        }
    }
}

const service = runtime.createService(documentService)


- Runtime
- EventSourcingFramework
- Services (Actions, Commands, Events, Queries, Projections)
- shared {
    FileStorage
    IdGenerator
}



// AiService

import {documentService} from 'domain/document
import {invoiceService} from 'domain/invoice

const onDocumentCreated = {
on: documentService.events.created.type
    handler(event, {call}){
    const invoice = analyzeDocument(event.document)
    call(invoiceService.command.createInvoice, invoice)
    }
}