@lota-sdk/core 0.4.8 → 0.4.9

package/src/services/attachment.service.ts

@@ -1,8 +1,14 @@
+import { Context, Effect, Layer } from 'effect'
+
 import type { RecordIdRef } from '../db/record-id'
 import { recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
-import { attachmentStorageService } from '../storage/attachment-storage.service'
-import type { UploadedThreadAttachment as SdkUploadedThreadAttachment } from '../storage/attachment-storage.service'
+import { runPromise } from '../effect/runtime'
+import type {
+  makeAttachmentStorageService,
+  UploadedThreadAttachment as SdkUploadedThreadAttachment,
+} from '../storage/attachment-storage.service'
+import { AttachmentStorageServiceTag } from '../storage/attachment-storage.service'
 import type { MessagePartLike, ReadableUploadMetadata as SdkReadableUploadMetadata } from '../storage/attachment-types'
 
 export type ReadableUploadMetadata = SdkReadableUploadMetadata
@@ -15,136 +21,152 @@ function toUserId(userId: RecordIdRef): string {
   return recordIdToString(userId, TABLES.USER)
 }
 
-class AttachmentService {
-  hydrateSignedFileUrlsInMessageParts({
-    parts,
-    orgId,
-    userId,
-  }: {
-    parts: readonly MessagePartLike[]
-    orgId: RecordIdRef
-    userId: RecordIdRef
-  }): MessagePartLike[] {
-    return attachmentStorageService.hydrateSignedFileUrlsInMessageParts({
+export function makeAttachmentService(attachmentStorage: ReturnType<typeof makeAttachmentStorageService>) {
+  return {
+    hydrateSignedFileUrlsInMessageParts<TPart extends MessagePartLike>({
       parts,
-      orgId: toOrgId(orgId),
-      userId: toUserId(userId),
-    })
-  }
+      orgId,
+      userId,
+    }: {
+      parts: readonly TPart[]
+      orgId: RecordIdRef
+      userId: RecordIdRef
+    }): TPart[] {
+      return attachmentStorage.hydrateSignedFileUrlsInMessageParts({
+        parts,
+        orgId: toOrgId(orgId),
+        userId: toUserId(userId),
+      })
+    },
 
-  listReadableUploadsFromMessages({
-    messages,
-    orgId,
-    userId,
-  }: {
-    messages: ReadonlyArray<{ parts: readonly MessagePartLike[] }>
-    orgId: RecordIdRef
-    userId: RecordIdRef
-  }): ReadableUploadMetadata[] {
-    return attachmentStorageService.listReadableUploadsFromMessages({
+    listReadableUploadsFromMessages<TPart extends MessagePartLike>({
       messages,
-      orgId: toOrgId(orgId),
-      userId: toUserId(userId),
-    })
-  }
+      orgId,
+      userId,
+    }: {
+      messages: ReadonlyArray<{ parts: readonly TPart[] }>
+      orgId: RecordIdRef
+      userId: RecordIdRef
+    }): ReadableUploadMetadata[] {
+      return attachmentStorage.listReadableUploadsFromMessages({
+        messages,
+        orgId: toOrgId(orgId),
+        userId: toUserId(userId),
+      })
+    },
 
-  async extractStoredAttachmentText({
-    storageKey,
-    name,
-    contentType,
-  }: {
-    storageKey: string
-    name: string
-    contentType: string
-  }): Promise<string> {
-    return attachmentStorageService.extractStoredAttachmentText({ storageKey, name, contentType })
-  }
+    extractStoredAttachmentText({
+      storageKey,
+      name,
+      contentType,
+    }: {
+      storageKey: string
+      name: string
+      contentType: string
+    }): Promise<string> {
+      return runPromise(attachmentStorage.extractStoredAttachmentText({ storageKey, name, contentType }))
+    },
 
-  async extractStoredAttachmentPages({
-    storageKey,
-    name,
-    contentType,
-  }: {
-    storageKey: string
-    name: string
-    contentType: string
-  }): Promise<{ pageMode: 'logical' | 'pdf'; pages: string[] }> {
-    return attachmentStorageService.extractStoredAttachmentPages({ storageKey, name, contentType })
-  }
+    extractStoredAttachmentPages({
+      storageKey,
+      name,
+      contentType,
+    }: {
+      storageKey: string
+      name: string
+      contentType: string
+    }): Promise<{ pageMode: 'logical' | 'pdf'; pages: string[] }> {
+      return runPromise(attachmentStorage.extractStoredAttachmentPages({ storageKey, name, contentType }))
+    },
 
-  async readFilePartsFromUpload({
-    upload,
-    orgId,
-    userId,
-    part,
-    pagesPerPart,
-  }: {
-    upload: ReadableUploadMetadata
-    orgId: RecordIdRef
-    userId: RecordIdRef
-    part?: number
-    pagesPerPart?: number
-  }) {
-    return attachmentStorageService.readFilePartsFromUpload({
+    readFilePartsFromUpload({
       upload,
-      orgId: toOrgId(orgId),
-      userId: toUserId(userId),
+      orgId,
+      userId,
       part,
       pagesPerPart,
-    })
-  }
+    }: {
+      upload: ReadableUploadMetadata
+      orgId: RecordIdRef
+      userId: RecordIdRef
+      part?: number
+      pagesPerPart?: number
+    }) {
+      return attachmentStorage.readFilePartsFromUpload({
+        upload,
+        orgId: toOrgId(orgId),
+        userId: toUserId(userId),
+        part,
+        pagesPerPart,
+      })
+    },
 
-  getAttachmentUrl(storageKey: string): string {
-    return attachmentStorageService.getAttachmentUrl(storageKey)
-  }
+    getAttachmentUrl(storageKey: string): string {
+      return attachmentStorage.getAttachmentUrl(storageKey)
+    },
 
-  async writeOrganizationDocument({
-    orgId,
-    namespace,
-    relativePath,
-    content,
-    contentType,
-  }: {
-    orgId: RecordIdRef
-    namespace: string
-    relativePath: string
-    content: string
-    contentType: string
-  }): Promise<{ storageKey: string; sizeBytes: number }> {
-    return attachmentStorageService.writeOrganizationDocument({
-      orgId: toOrgId(orgId),
+    writeOrganizationDocument({
+      orgId,
       namespace,
       relativePath,
       content,
       contentType,
-    })
-  }
+    }: {
+      orgId: RecordIdRef
+      namespace: string
+      relativePath: string
+      content: string
+      contentType: string
+    }): Promise<{ storageKey: string; sizeBytes: number }> {
+      return runPromise(
+        attachmentStorage.writeOrganizationDocument({
+          orgId: toOrgId(orgId),
+          namespace,
+          relativePath,
+          content,
+          contentType,
+        }),
+      )
+    },
 
-  async uploadOrganizationDocument({
-    file,
-    orgId,
-    namespace,
-    relativePath,
-  }: {
-    file: File
-    orgId: RecordIdRef
-    namespace: string
-    relativePath: string
-  }) {
-    return attachmentStorageService.uploadOrganizationDocument({ file, orgId: toOrgId(orgId), namespace, relativePath })
-  }
+    uploadOrganizationDocument({
+      file,
+      orgId,
+      namespace,
+      relativePath,
+    }: {
+      file: File
+      orgId: RecordIdRef
+      namespace: string
+      relativePath: string
+    }) {
+      return attachmentStorage.uploadOrganizationDocument({ file, orgId: toOrgId(orgId), namespace, relativePath })
+    },
 
-  async uploadThreadAttachment({
-    file,
-    orgId,
-    userId,
-  }: {
-    file: File
-    orgId: RecordIdRef
-    userId: RecordIdRef
-  }): Promise<SdkUploadedThreadAttachment> {
-    return attachmentStorageService.uploadThreadAttachment({ file, orgId: toOrgId(orgId), userId: toUserId(userId) })
+    uploadThreadAttachment({
+      file,
+      orgId,
+      userId,
+    }: {
+      file: File
+      orgId: RecordIdRef
+      userId: RecordIdRef
+    }): Promise<SdkUploadedThreadAttachment> {
+      return runPromise(
+        attachmentStorage.uploadThreadAttachment({ file, orgId: toOrgId(orgId), userId: toUserId(userId) }),
+      )
+    },
   }
 }
 
-export const attachmentService = new AttachmentService()
+export class AttachmentServiceTag extends Context.Service<
+  AttachmentServiceTag,
+  ReturnType<typeof makeAttachmentService>
+>()('AttachmentService') {}
+
+export const AttachmentServiceLive = Layer.effect(
+  AttachmentServiceTag,
+  Effect.map(AttachmentStorageServiceTag.asEffect(), (attachmentStorageService) =>
+    makeAttachmentService(attachmentStorageService),
+  ),
+)