@lota-sdk/core 0.4.7 → 0.4.9

package/src/storage/attachment-storage.service.ts

@@ -1,8 +1,12 @@
 import { inferContentType } from '@lota-sdk/shared'
 import { S3Client } from 'bun'
+import { Context, Schema, Effect, Layer } from 'effect'
 
 import { serverLogger } from '../config/logger'
-import { getRuntimeConfig } from '../runtime/runtime-config'
+import { BadRequestError, ForbiddenError } from '../effect/errors'
+import { RuntimeConfigServiceTag } from '../effect/services'
+import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
+import { getErrorMessage } from '../utils/errors'
 import { readString } from '../utils/string'
 import {
   extractAttachmentText,
@@ -10,12 +14,7 @@ import {
   isPdfAttachmentFile,
   splitExtractedTextIntoPages,
 } from './attachment-parser'
-import type {
-  MessagePartLike,
-  ReadableUploadMetadata,
-  ReadableUploadPageMode,
-  ReadableUploadPagePart,
-} from './attachment-types'
+import type { MessagePartLike, ReadableUploadMetadata } from './attachment-types'
 import {
   buildOrganizationDocumentStorageKey,
   buildUploadStorageKey,
@@ -37,161 +36,170 @@ export type UploadedThreadAttachment = {
 
 type AttachmentContextCandidate = { storageKey: string; name: string; contentType: string; sizeBytes: number | null }
 
-export class AttachmentStorageService {
-  private readonly client: S3Client
-
-  constructor() {
-    const config = getRuntimeConfig()
-    this.client = new S3Client({
-      accessKeyId: config.s3.accessKeyId,
-      secretAccessKey: config.s3.secretAccessKey,
-      bucket: config.s3.bucket,
-      endpoint: config.s3.endpoint,
-      region: config.s3.region,
-    })
-  }
+class AttachmentStorageError extends Schema.TaggedErrorClass<AttachmentStorageError>()('AttachmentStorageError', {
+  operation: Schema.String,
+  message: Schema.String,
+  cause: Schema.Defect,
+}) {}
 
-  getAttachmentUrl(storageKey: string): string {
-    return this.client.file(storageKey).presign({ expiresIn: getRuntimeConfig().s3.attachmentUrlExpiresIn })
-  }
+function toAttachmentStorageError(operation: string, cause: unknown): AttachmentStorageError {
+  return new AttachmentStorageError({ operation, message: getErrorMessage(cause), cause })
+}
 
-  async writeOrganizationDocument({
-    orgId,
-    namespace,
-    relativePath,
-    content,
-    contentType,
-  }: {
-    orgId: string
-    namespace: string
-    relativePath: string
-    content: string
-    contentType: string
-  }): Promise<{ storageKey: string; sizeBytes: number }> {
-    const storageKey = buildOrganizationDocumentStorageKey({ orgId, namespace, relativePath })
-    const sizeBytes = Buffer.byteLength(content, 'utf8')
+export function makeAttachmentStorageService(config: ResolvedLotaRuntimeConfig) {
+  const client = new S3Client({
+    accessKeyId: config.s3.accessKeyId,
+    secretAccessKey: config.s3.secretAccessKey,
+    bucket: config.s3.bucket,
+    endpoint: config.s3.endpoint,
+    region: config.s3.region,
+  })
+
+  function getAttachmentUrl(storageKey: string): string {
+    return client.file(storageKey).presign({ expiresIn: config.s3.attachmentUrlExpiresIn })
+  }
 
-    await this.client.file(storageKey).write(new Blob([content]), { type: contentType })
+  function readFilenameFromStorageKey(storageKey: string): string | null {
+    const slashIndex = storageKey.lastIndexOf('/')
+    if (slashIndex < 0) return null
+    const rawName = storageKey.slice(slashIndex + 1).trim()
+    if (!rawName) return null
 
-    return { storageKey, sizeBytes }
+    const dashIndex = rawName.indexOf('-')
+    if (dashIndex <= 0 || dashIndex === rawName.length - 1) return rawName
+    return rawName.slice(dashIndex + 1)
   }
 
-  async uploadOrganizationDocument({
-    file,
+  function collectAttachmentContextCandidates({
+    parts,
     orgId,
-    namespace,
-    relativePath,
+    userId,
   }: {
-    file: File
+    parts: readonly MessagePartLike[]
     orgId: string
-    namespace: string
-    relativePath: string
-  }): Promise<UploadedThreadAttachment> {
-    const filename = file.name || 'document'
-    const mediaType = file.type || inferContentType(filename)
-    const storageKey = buildOrganizationDocumentStorageKey({
-      orgId,
-      namespace,
-      relativePath: relativePath.trim().length > 0 ? relativePath : filename,
-    })
+    userId: string
+  }): AttachmentContextCandidate[] {
+    const storagePrefix = buildUploadStoragePrefix({ orgId, userId })
+    const candidates: AttachmentContextCandidate[] = []
 
-    await this.client.file(storageKey).write(file, { type: mediaType })
+    for (const part of parts) {
+      if (part.type !== 'file') continue
 
-    return {
-      filename,
-      mediaType,
-      sizeBytes: file.size,
-      storageKey,
-      url: this.getAttachmentUrl(storageKey),
-      expiresInSeconds: getRuntimeConfig().s3.attachmentUrlExpiresIn,
+      const providerMetadata = readRecord(part.providerMetadata)
+      const lotaMetadata = readRecord(providerMetadata?.lota)
+      const storageKey = readString(lotaMetadata?.attachmentStorageKey)
+      if (!storageKey || !storageKey.startsWith(storagePrefix)) continue
+
+      const name = readString(part.filename) ?? readFilenameFromStorageKey(storageKey) ?? 'Attachment'
+      const contentType = readString(part.mediaType) ?? inferContentType(name)
+      const sizeBytes = readNonNegativeInteger(lotaMetadata?.attachmentSizeBytes)
+      candidates.push({ storageKey, name, contentType, sizeBytes })
     }
+
+    return candidates
   }
 
-  async uploadThreadAttachment({
-    file,
+  function assertUploadOwnership({
+    storageKey,
     orgId,
     userId,
   }: {
-    file: File
+    storageKey: string
     orgId: string
     userId: string
-  }): Promise<UploadedThreadAttachment> {
-    const filename = file.name || 'attachment'
-    const mediaType = file.type || inferContentType(filename)
-    const sizeBytes = file.size
-    const storageKey = buildUploadStorageKey({ orgId, userId, filename, uploadId: Bun.randomUUIDv7() })
-
-    await this.client.file(storageKey).write(file, { type: mediaType })
-
-    return {
-      filename,
-      mediaType,
-      sizeBytes,
-      storageKey,
-      url: this.getAttachmentUrl(storageKey),
-      expiresInSeconds: getRuntimeConfig().s3.attachmentUrlExpiresIn,
+  }): void {
+    const storagePrefix = buildUploadStoragePrefix({ orgId, userId })
+    if (!storageKey.startsWith(storagePrefix)) {
+      throw new ForbiddenError({ message: 'Upload does not belong to the current organization/user scope.' })
     }
   }
 
-  hydrateSignedFileUrlsInMessageParts({
-    parts,
+  function writeOrganizationDocumentEffect({
     orgId,
-    userId,
+    namespace,
+    relativePath,
+    content,
+    contentType,
   }: {
-    parts: readonly MessagePartLike[]
     orgId: string
-    userId: string
-  }): MessagePartLike[] {
-    const storagePrefix = buildUploadStoragePrefix({ orgId, userId })
-
-    return parts.map((part) => {
-      if (part.type !== 'file') return part
+    namespace: string
+    relativePath: string
+    content: string
+    contentType: string
+  }) {
+    return Effect.gen(function* () {
+      const storageKey = buildOrganizationDocumentStorageKey({ orgId, namespace, relativePath })
+      const sizeBytes = Buffer.byteLength(content, 'utf8')
 
-      const providerMetadata = readRecord(part.providerMetadata)
-      const lotaMetadata = readRecord(providerMetadata?.lota)
-      const storageKey = lotaMetadata?.attachmentStorageKey
-      if (typeof storageKey !== 'string' || !storageKey.startsWith(storagePrefix)) return part
+      yield* Effect.tryPromise({
+        try: () => client.file(storageKey).write(new Blob([content]), { type: contentType }),
+        catch: (error) => toAttachmentStorageError('writeOrganizationDocument', error),
+      })
 
-      return { ...part, url: this.getAttachmentUrl(storageKey) }
+      return { storageKey, sizeBytes }
     })
   }
 
-  listReadableUploadsFromMessages({
-    messages,
+  function uploadOrganizationDocumentEffect({
+    file,
     orgId,
-    userId,
+    namespace,
+    relativePath,
   }: {
-    messages: ReadonlyArray<{ parts: readonly MessagePartLike[] }>
+    file: File
     orgId: string
-    userId: string
-  }): ReadableUploadMetadata[] {
-    const uploadsByStorageKey = new Map<
-      string,
-      { storageKey: string; filename: string; mediaType: string; sizeBytes: number | null }
-    >()
-
-    for (const message of messages) {
-      const candidates = this.collectAttachmentContextCandidates({ parts: message.parts, orgId, userId })
-      for (const candidate of candidates) {
-        if (uploadsByStorageKey.has(candidate.storageKey)) continue
-        uploadsByStorageKey.set(candidate.storageKey, {
-          storageKey: candidate.storageKey,
-          filename: candidate.name,
-          mediaType: candidate.contentType,
-          sizeBytes: candidate.sizeBytes,
-        })
+    namespace: string
+    relativePath: string
+  }) {
+    return Effect.gen(function* () {
+      const filename = file.name || 'document'
+      const mediaType = file.type || inferContentType(filename)
+      const storageKey = buildOrganizationDocumentStorageKey({
+        orgId,
+        namespace,
+        relativePath: relativePath.trim().length > 0 ? relativePath : filename,
+      })
+
+      yield* Effect.tryPromise({
+        try: () => client.file(storageKey).write(file, { type: mediaType }),
+        catch: (error) => toAttachmentStorageError('uploadOrganizationDocument', error),
+      })
+
+      return {
+        filename,
+        mediaType,
+        sizeBytes: file.size,
+        storageKey,
+        url: getAttachmentUrl(storageKey),
+        expiresInSeconds: config.s3.attachmentUrlExpiresIn,
       }
-    }
+    })
+  }
 
-    return [...uploadsByStorageKey.values()].map((upload) => ({
-      storageKey: upload.storageKey,
-      filename: upload.filename,
-      mediaType: upload.mediaType,
-      sizeBytes: upload.sizeBytes,
-    }))
+  function uploadThreadAttachmentEffect({ file, orgId, userId }: { file: File; orgId: string; userId: string }) {
+    return Effect.gen(function* () {
+      const filename = file.name || 'attachment'
+      const mediaType = file.type || inferContentType(filename)
+      const sizeBytes = file.size
+      const storageKey = buildUploadStorageKey({ orgId, userId, filename, uploadId: Bun.randomUUIDv7() })
+
+      yield* Effect.tryPromise({
+        try: () => client.file(storageKey).write(file, { type: mediaType }),
+        catch: (error) => toAttachmentStorageError('uploadThreadAttachment', error),
+      })
+
+      return {
+        filename,
+        mediaType,
+        sizeBytes,
+        storageKey,
+        url: getAttachmentUrl(storageKey),
+        expiresInSeconds: config.s3.attachmentUrlExpiresIn,
+      }
+    })
   }
 
-  async extractStoredAttachmentText({
+  function extractStoredAttachmentTextEffect({
     storageKey,
     name,
     contentType,
@@ -199,18 +207,30 @@ export class AttachmentStorageService {
     storageKey: string
     name: string
     contentType: string
-  }): Promise<string> {
-    try {
-      const s3File = this.client.file(storageKey)
-      const fileLike = new File([await s3File.arrayBuffer()], name, { type: contentType })
-      return await extractAttachmentText(fileLike)
-    } catch (error) {
-      serverLogger.warn`Failed to extract stored attachment text: ${error}`
-      return ''
-    }
+  }) {
+    return Effect.gen(function* () {
+      const s3File = client.file(storageKey)
+      const bytes = yield* Effect.tryPromise({
+        try: () => s3File.arrayBuffer(),
+        catch: (error) => toAttachmentStorageError('extractStoredAttachmentText:read', error),
+      })
+      const fileLike = new File([bytes], name, { type: contentType })
+
+      return yield* Effect.tryPromise({
+        try: () => extractAttachmentText(fileLike),
+        catch: (error) => toAttachmentStorageError('extractStoredAttachmentText:extract', error),
+      })
+    }).pipe(
+      Effect.catch((error) =>
+        Effect.sync(() => {
+          serverLogger.warn`Failed to extract stored attachment text: ${error}`
+          return ''
+        }),
+      ),
+    )
   }
 
-  async extractStoredAttachmentPages({
+  function extractStoredAttachmentPagesEffect({
     storageKey,
     name,
     contentType,
@@ -218,25 +238,39 @@ export class AttachmentStorageService {
     storageKey: string
     name: string
     contentType: string
-  }): Promise<{ pageMode: ReadableUploadPageMode; pages: string[] }> {
-    try {
-      const s3File = this.client.file(storageKey)
-      const fileLike = new File([await s3File.arrayBuffer()], name, { type: contentType })
+  }) {
+    return Effect.gen(function* () {
+      const s3File = client.file(storageKey)
+      const bytes = yield* Effect.tryPromise({
+        try: () => s3File.arrayBuffer(),
+        catch: (error) => toAttachmentStorageError('extractStoredAttachmentPages:read', error),
+      })
+      const fileLike = new File([bytes], name, { type: contentType })
 
       if (isPdfAttachmentFile(fileLike)) {
-        const pages = await extractPdfPages(fileLike)
-        return { pageMode: 'pdf', pages }
+        const pages = yield* Effect.tryPromise({
+          try: () => extractPdfPages(fileLike),
+          catch: (error) => toAttachmentStorageError('extractStoredAttachmentPages:pdf', error),
+        })
+        return { pageMode: 'pdf' as const, pages }
       }
 
-      const extractedText = await extractAttachmentText(fileLike)
-      return { pageMode: 'logical', pages: splitExtractedTextIntoPages(extractedText) }
-    } catch (error) {
-      serverLogger.warn`Failed to extract attachment pages from storage: ${error}`
-      return { pageMode: 'logical', pages: [] }
-    }
+      const extractedText = yield* Effect.tryPromise({
+        try: () => extractAttachmentText(fileLike),
+        catch: (error) => toAttachmentStorageError('extractStoredAttachmentPages:text', error),
+      })
+      return { pageMode: 'logical' as const, pages: splitExtractedTextIntoPages(extractedText) }
+    }).pipe(
+      Effect.catch((error) =>
+        Effect.sync(() => {
+          serverLogger.warn`Failed to extract attachment pages from storage: ${error}`
+          return { pageMode: 'logical' as const, pages: [] }
+        }),
+      ),
+    )
   }
 
-  async readFilePartsFromUpload({
+  function readFilePartsFromUploadEffect({
     upload,
     orgId,
     userId,
@@ -248,145 +282,167 @@ export class AttachmentStorageService {
     userId: string
     part?: number
     pagesPerPart?: number
-  }): Promise<{
-    pageMode: ReadableUploadPageMode
-    totalPages: number
-    fullPageLength: number
-    currentPart: number
-    totalParts: number
-    hasNextPart: boolean
-    hasPreviousPart: boolean
-    pagesPerPart: number
-    pageStart: number
-    pageEnd: number
-    data: ReadableUploadPagePart[]
-  }> {
-    this.assertUploadOwnership({ storageKey: upload.storageKey, orgId, userId })
-
-    const parsed = await this.extractStoredAttachmentPages({
-      storageKey: upload.storageKey,
-      name: upload.filename,
-      contentType: upload.mediaType,
-    })
-    const totalPages = parsed.pages.length
-    if (totalPages === 0) {
-      return {
-        pageMode: parsed.pageMode,
-        totalPages: 0,
-        fullPageLength: 0,
-        currentPart: 1,
-        totalParts: 0,
-        hasNextPart: false,
-        hasPreviousPart: false,
-        pagesPerPart,
-        pageStart: 1,
-        pageEnd: 0,
-        data: [],
+  }) {
+    return Effect.gen(function* () {
+      assertUploadOwnership({ storageKey: upload.storageKey, orgId, userId })
+
+      const parsed = yield* extractStoredAttachmentPagesEffect({
+        storageKey: upload.storageKey,
+        name: upload.filename,
+        contentType: upload.mediaType,
+      })
+      const totalPages = parsed.pages.length
+      if (totalPages === 0) {
+        return {
+          pageMode: parsed.pageMode,
+          totalPages: 0,
+          fullPageLength: 0,
+          currentPart: 1,
+          totalParts: 0,
+          hasNextPart: false,
+          hasPreviousPart: false,
+          pagesPerPart,
+          pageStart: 1,
+          pageEnd: 0,
+          data: [],
+        }
       }
-    }
 
-    if (!Number.isInteger(pagesPerPart) || pagesPerPart <= 0) {
-      throw new Error('pagesPerPart must be a positive integer.')
-    }
-    if (!Number.isInteger(part) || part <= 0) {
-      throw new Error('part must be an integer greater than or equal to 1.')
-    }
+      if (!Number.isInteger(pagesPerPart) || pagesPerPart <= 0) {
+        return yield* new BadRequestError({ message: 'pagesPerPart must be a positive integer.' })
+      }
+      if (!Number.isInteger(part) || part <= 0) {
+        return yield* new BadRequestError({ message: 'part must be an integer greater than or equal to 1.' })
+      }
 
-    const totalParts = Math.ceil(totalPages / pagesPerPart)
-    if (part > totalParts) {
-      throw new Error(`part ${part} exceeds total parts ${totalParts}.`)
-    }
+      const totalParts = Math.ceil(totalPages / pagesPerPart)
+      if (part > totalParts) {
+        return yield* new BadRequestError({ message: `part ${part} exceeds total parts ${totalParts}.` })
+      }
 
-    const pageStart = (part - 1) * pagesPerPart + 1
-    const pageEnd = Math.min(pageStart + pagesPerPart - 1, totalPages)
-
-    const data = parsed.pages
-      .slice(pageStart - 1, pageEnd)
-      .map((text, index) => ({ pageNumber: pageStart + index, text, charCount: text.length }))
-
-    return {
-      pageMode: parsed.pageMode,
-      totalPages,
-      fullPageLength: totalPages,
-      currentPart: part,
-      totalParts,
-      hasNextPart: part < totalParts,
-      hasPreviousPart: part > 1,
-      pagesPerPart,
-      pageStart,
-      pageEnd,
-      data,
-    }
-  }
+      const pageStart = (part - 1) * pagesPerPart + 1
+      const pageEnd = Math.min(pageStart + pagesPerPart - 1, totalPages)
 
-  private assertUploadOwnership({
-    storageKey,
-    orgId,
-    userId,
-  }: {
-    storageKey: string
-    orgId: string
-    userId: string
-  }): void {
-    const storagePrefix = buildUploadStoragePrefix({ orgId, userId })
-    if (!storageKey.startsWith(storagePrefix)) {
-      throw new Error('Upload does not belong to the current organization/user scope.')
-    }
-  }
+      const data = parsed.pages
+        .slice(pageStart - 1, pageEnd)
+        .map((text, index) => ({ pageNumber: pageStart + index, text, charCount: text.length }))
 
-  private collectAttachmentContextCandidates({
-    parts,
-    orgId,
-    userId,
-  }: {
-    parts: readonly MessagePartLike[]
-    orgId: string
-    userId: string
-  }): AttachmentContextCandidate[] {
-    const storagePrefix = buildUploadStoragePrefix({ orgId, userId })
-    const candidates: AttachmentContextCandidate[] = []
-
-    for (const part of parts) {
-      if (part.type !== 'file') continue
-
-      const providerMetadata = readRecord(part.providerMetadata)
-      const lotaMetadata = readRecord(providerMetadata?.lota)
-      const storageKey = readString(lotaMetadata?.attachmentStorageKey)
-      if (!storageKey || !storageKey.startsWith(storagePrefix)) continue
+      return {
+        pageMode: parsed.pageMode,
+        totalPages,
+        fullPageLength: totalPages,
+        currentPart: part,
+        totalParts,
+        hasNextPart: part < totalParts,
+        hasPreviousPart: part > 1,
+        pagesPerPart,
+        pageStart,
+        pageEnd,
+        data,
+      }
+    })
+  }
 
-      const name = readString(part.filename) ?? this.readFilenameFromStorageKey(storageKey) ?? 'Attachment'
-      const contentType = readString(part.mediaType) ?? inferContentType(name)
-      const sizeBytes = readNonNegativeInteger(lotaMetadata?.attachmentSizeBytes)
-      candidates.push({ storageKey, name, contentType, sizeBytes })
-    }
+  return {
+    getAttachmentUrl,
 
-    return candidates
-  }
+    writeOrganizationDocument: (params: {
+      orgId: string
+      namespace: string
+      relativePath: string
+      content: string
+      contentType: string
+    }) => writeOrganizationDocumentEffect(params),
 
-  private readFilenameFromStorageKey(storageKey: string): string | null {
-    const slashIndex = storageKey.lastIndexOf('/')
-    if (slashIndex < 0) return null
-    const rawName = storageKey.slice(slashIndex + 1).trim()
-    if (!rawName) return null
+    uploadOrganizationDocument: (params: { file: File; orgId: string; namespace: string; relativePath: string }) =>
+      uploadOrganizationDocumentEffect(params),
 
-    const dashIndex = rawName.indexOf('-')
-    if (dashIndex <= 0 || dashIndex === rawName.length - 1) return rawName
-    return rawName.slice(dashIndex + 1)
-  }
-}
+    uploadThreadAttachment: (params: { file: File; orgId: string; userId: string }) =>
+      uploadThreadAttachmentEffect(params),
 
-let _attachmentStorageService: AttachmentStorageService | undefined
+    hydrateSignedFileUrlsInMessageParts<TPart extends MessagePartLike>({
+      parts,
+      orgId,
+      userId,
+    }: {
+      parts: readonly TPart[]
+      orgId: string
+      userId: string
+    }): TPart[] {
+      const storagePrefix = buildUploadStoragePrefix({ orgId, userId })
+
+      return parts.map<TPart>((part) => {
+        if (part.type !== 'file') return part
+
+        const providerMetadata = readRecord(part.providerMetadata)
+        const lotaMetadata = readRecord(providerMetadata?.lota)
+        const storageKey = lotaMetadata?.attachmentStorageKey
+        if (typeof storageKey !== 'string' || !storageKey.startsWith(storagePrefix)) return part
+
+        return { ...part, url: getAttachmentUrl(storageKey) }
+      })
+    },
+
+    listReadableUploadsFromMessages<TPart extends MessagePartLike>({
+      messages,
+      orgId,
+      userId,
+    }: {
+      messages: ReadonlyArray<{ parts: readonly TPart[] }>
+      orgId: string
+      userId: string
+    }): ReadableUploadMetadata[] {
+      const uploadsByStorageKey = new Map<
+        string,
+        { storageKey: string; filename: string; mediaType: string; sizeBytes: number | null }
+      >()
+
+      for (const message of messages) {
+        const candidates = collectAttachmentContextCandidates({ parts: message.parts, orgId, userId })
+        for (const candidate of candidates) {
+          if (uploadsByStorageKey.has(candidate.storageKey)) continue
+          uploadsByStorageKey.set(candidate.storageKey, {
+            storageKey: candidate.storageKey,
+            filename: candidate.name,
+            mediaType: candidate.contentType,
+            sizeBytes: candidate.sizeBytes,
+          })
+        }
+      }
 
-/** @lintignore */
-export function getAttachmentStorageService(): AttachmentStorageService {
-  if (!_attachmentStorageService) {
-    _attachmentStorageService = new AttachmentStorageService()
+      return [...uploadsByStorageKey.values()].map((upload) => ({
+        storageKey: upload.storageKey,
+        filename: upload.filename,
+        mediaType: upload.mediaType,
+        sizeBytes: upload.sizeBytes,
+      }))
+    },
+
+    extractStoredAttachmentText: (params: { storageKey: string; name: string; contentType: string }) =>
+      extractStoredAttachmentTextEffect(params),
+
+    extractStoredAttachmentPages: (params: { storageKey: string; name: string; contentType: string }) =>
+      extractStoredAttachmentPagesEffect(params),
+
+    readFilePartsFromUpload: (params: {
+      upload: ReadableUploadMetadata
+      orgId: string
+      userId: string
+      part?: number
+      pagesPerPart?: number
+    }) => readFilePartsFromUploadEffect(params),
   }
-  return _attachmentStorageService
 }
 
-export const attachmentStorageService = new Proxy({} as AttachmentStorageService, {
-  get(_target, prop: string): unknown {
-    return Reflect.get(getAttachmentStorageService(), prop)
-  },
-})
+export class AttachmentStorageServiceTag extends Context.Service<
+  AttachmentStorageServiceTag,
+  ReturnType<typeof makeAttachmentStorageService>
+>()('AttachmentStorageService') {}
+
+export const AttachmentStorageServiceLive = Layer.effect(
+  AttachmentStorageServiceTag,
+  Effect.gen(function* () {
+    const config = yield* RuntimeConfigServiceTag
+    return makeAttachmentStorageService(config)
+  }),
+)