@lota-sdk/core 0.4.8 → 0.4.9

package/src/services/artifact.service.ts

@@ -4,17 +4,21 @@ import type {
   ArtifactReference,
   ArtifactStatus,
   ArtifactVersionSummary,
-  GetArtifactResult,
   PublishArtifactArgs,
 } from '@lota-sdk/shared'
+import { Cause, Context, Effect, Layer } from 'effect'
 import { BoundQuery } from 'surrealdb'
 
 import type { RecordIdInput } from '../db/record-id'
 import { ensureRecordId, recordIdToString } from '../db/record-id'
-import { databaseService } from '../db/service'
-import type { DatabaseTransaction } from '../db/service'
+import type { SurrealDBService, DatabaseTransaction } from '../db/service'
 import { TABLES } from '../db/tables'
-import { generatedDocumentStorageService } from '../storage/generated-document-storage.service'
+import { ConfigurationError, DatabaseError, NotFoundError } from '../effect/errors'
+import { DatabaseServiceTag } from '../effect/services'
+import { toValidationError } from '../effect/zod'
+import type { makeGeneratedDocumentStorageService } from '../storage/generated-document-storage.service'
+import { GeneratedDocumentStorageServiceTag } from '../storage/generated-document-storage.service'
+import { sha256Hex } from '../utils/crypto'
 import { toIsoDateTimeString } from '../utils/date-time'
 
 const ARTIFACT_PUBLISH_MAX_ATTEMPTS = 5
@@ -48,14 +52,6 @@ function describePublishInputShape(value: unknown): string {
   return typeof value
 }
 
-function formatPublishError(error: unknown): string {
-  if (error instanceof Error && error.message.trim()) {
-    return error.message
-  }
-
-  return typeof error === 'string' ? error : JSON.stringify(error)
-}
-
 function slugify(value: string): string {
   const normalized = value
     .trim()
@@ -70,7 +66,7 @@ function encodeStorageSegment(value: string): string {
 }
 
 function hashCanonicalSegment(value: string): string {
-  return new Bun.CryptoHasher('sha256').update(value.trim()).digest('hex')
+  return sha256Hex(value.trim())
 }
 
 function buildCanonicalKey(
@@ -160,61 +156,69 @@ function isRetryablePublishError(error: unknown): boolean {
 
 interface PublishArtifactTransactionOptions {
   onStorageWrite?: (storageKey: string) => void
-  onStorageCleanup?: (storageKey: string) => void
 }
 
-class ArtifactService {
-  private async listArtifactsForCanonicalKeyInTransaction(params: {
+interface ArtifactServiceDeps {
+  db: SurrealDBService
+  storage: ReturnType<typeof makeGeneratedDocumentStorageService>
+}
+
+export function makeArtifactService(deps: ArtifactServiceDeps) {
+  const { db, storage } = deps
+
+  const listArtifactsForCanonicalKeyInTransactionEffect = (params: {
     tx: DatabaseTransaction
     organizationId: string
     canonicalKey: string
-  }): Promise<ArtifactRecord[]> {
-    const records = await params.tx.query({
-      query: `SELECT * FROM ${TABLES.ARTIFACT} WHERE organizationId = $organizationId AND canonicalKey = $canonicalKey ORDER BY version DESC`,
-      bindings: {
-        organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-        canonicalKey: params.canonicalKey,
-      },
+  }) =>
+    Effect.gen(function* () {
+      const records = yield* params.tx.query({
+        query: `SELECT * FROM ${TABLES.ARTIFACT} WHERE organizationId = $organizationId AND canonicalKey = $canonicalKey ORDER BY version DESC`,
+        bindings: {
+          organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
+          canonicalKey: params.canonicalKey,
+        },
+      })
+
+      return ArtifactRecordSchema.array().parse(records)
     })
 
-    return ArtifactRecordSchema.array().parse(records)
-  }
-
-  async publishArtifactInTransaction(
+  const publishArtifactInTransactionEffect = (
     args: PublishArtifactArgs,
     tx: DatabaseTransaction,
     options: PublishArtifactTransactionOptions = {},
-  ): Promise<ArtifactRecord> {
-    let params: PublishArtifactArgs
-    try {
-      params = PublishArtifactArgsSchema.parse(args)
-    } catch (error) {
-      throw new Error(
-        `artifact service transaction input parse failed (${describePublishInputShape(args)}): ${formatPublishError(error)}`,
-      )
-    }
-    const organizationRef = ensureRecordId(params.organizationId, TABLES.ORGANIZATION)
-    const canonicalKey = buildCanonicalKey(params)
-    const existing = await this.listArtifactsForCanonicalKeyInTransaction({
-      tx,
-      organizationId: params.organizationId,
-      canonicalKey,
-    })
-    const latestVersion = existing.reduce((max, record) => Math.max(max, record.version), 0)
-    const version = latestVersion + 1
-    const publishAttemptId = Bun.randomUUIDv7()
-    const references = extractInternalReferences(params.content)
-    const stored = await generatedDocumentStorageService.writeTextArtifact({
-      organizationId: params.organizationId,
-      namespace: 'artifacts',
-      relativePath: buildArtifactRelativePath({ canonicalKey, version, title: params.title, publishAttemptId }),
-      content: params.content,
-      mediaType: 'text/markdown',
-    })
-    options.onStorageWrite?.(stored.storageKey)
+  ) =>
+    Effect.gen(function* () {
+      const parsedArgs = PublishArtifactArgsSchema.safeParse(args)
+      if (!parsedArgs.success) {
+        return yield* toValidationError(
+          parsedArgs.error,
+          `artifact service transaction input parse failed (${describePublishInputShape(args)})`,
+        )
+      }
 
-    try {
-      const createdResult = await tx
+      const params = parsedArgs.data
+      const organizationRef = ensureRecordId(params.organizationId, TABLES.ORGANIZATION)
+      const canonicalKey = buildCanonicalKey(params)
+      const existing = yield* listArtifactsForCanonicalKeyInTransactionEffect({
+        tx,
+        organizationId: params.organizationId,
+        canonicalKey,
+      })
+      const latestVersion = existing.reduce((max, record) => Math.max(max, record.version), 0)
+      const version = latestVersion + 1
+      const publishAttemptId = Bun.randomUUIDv7()
+      const references = extractInternalReferences(params.content)
+      const stored = yield* storage.writeTextArtifact({
+        organizationId: params.organizationId,
+        namespace: 'artifacts',
+        relativePath: buildArtifactRelativePath({ canonicalKey, version, title: params.title, publishAttemptId }),
+        content: params.content,
+        mediaType: 'text/markdown',
+      })
+      options.onStorageWrite?.(stored.storageKey)
+
+      const createdResult = yield* tx
         .create(TABLES.ARTIFACT)
         .content({
           organizationId: organizationRef,
@@ -238,138 +242,211 @@ class ArtifactService {
         .output('after')
       const createdRecord: unknown = Array.isArray(createdResult) ? createdResult.at(0) : createdResult
       if (!createdRecord) {
-        throw new Error(`Artifact create returned no record for canonical key ${canonicalKey}.`)
+        return yield* new ConfigurationError({
+          message: `Artifact create returned no record for canonical key ${canonicalKey}.`,
+        })
       }
 
       const created = ArtifactRecordSchema.parse(createdRecord)
 
       const previousActive = existing.find((record) => record.status === 'active')
       if (previousActive) {
-        await tx
+        yield* tx
           .update(ensureRecordId(previousActive.id, TABLES.ARTIFACT))
           .merge({ status: 'superseded', supersededBy: ensureRecordId(created.id, TABLES.ARTIFACT) })
           .output('after')
       }
 
       return created
-    } catch (error) {
-      await generatedDocumentStorageService.deleteTextArtifact(stored.storageKey).catch(() => undefined)
-      options.onStorageCleanup?.(stored.storageKey)
-      throw error
-    }
-  }
+    })
 
-  async publishArtifact(args: PublishArtifactArgs): Promise<ArtifactRecord> {
-    let params: PublishArtifactArgs
-    try {
-      params = PublishArtifactArgsSchema.parse(args)
-    } catch (error) {
-      throw new Error(
-        `artifact service input parse failed (${describePublishInputShape(args)}): ${formatPublishError(error)}`,
-      )
-    }
+  const publishArtifactEffect = (args: PublishArtifactArgs) =>
+    Effect.gen(function* () {
+      const parsedArgs = PublishArtifactArgsSchema.safeParse(args)
+      if (!parsedArgs.success) {
+        return yield* toValidationError(
+          parsedArgs.error,
+          `artifact service input parse failed (${describePublishInputShape(args)})`,
+        )
+      }
 
-    let lastError: unknown = null
-    for (let attempt = 1; attempt <= ARTIFACT_PUBLISH_MAX_ATTEMPTS; attempt += 1) {
-      const publishAttemptState: { pendingStorageKey?: string } = {}
-      try {
-        return await databaseService.withTransaction(
-          async (tx) =>
-            await this.publishArtifactInTransaction(params, tx, {
+      const params = parsedArgs.data
+      let lastError: unknown = null
+      for (let attempt = 1; attempt <= ARTIFACT_PUBLISH_MAX_ATTEMPTS; attempt += 1) {
+        const publishAttemptState: { pendingStorageKey?: string } = {}
+        const attemptExit = yield* Effect.exit(
+          db.withTransaction((tx) =>
+            publishArtifactInTransactionEffect(params, tx, {
               onStorageWrite: (storageKey) => {
                 publishAttemptState.pendingStorageKey = storageKey
               },
-              onStorageCleanup: (storageKey) => {
-                if (publishAttemptState.pendingStorageKey === storageKey) {
-                  publishAttemptState.pendingStorageKey = undefined
-                }
-              },
             }),
+          ),
         )
-      } catch (error) {
+        if (attemptExit._tag === 'Success') {
+          return attemptExit.value
+        }
+
+        const error = Cause.squash(attemptExit.cause)
         const storageKeyToCleanup = publishAttemptState.pendingStorageKey
         publishAttemptState.pendingStorageKey = undefined
         if (typeof storageKeyToCleanup === 'string') {
-          await generatedDocumentStorageService.deleteTextArtifact(storageKeyToCleanup).catch(() => undefined)
+          yield* Effect.ignore(storage.deleteTextArtifact(storageKeyToCleanup))
         }
         lastError = error
         if (!isRetryablePublishError(error) || attempt === ARTIFACT_PUBLISH_MAX_ATTEMPTS) {
-          throw error
+          if (error instanceof Error) {
+            return yield* Effect.fail(error)
+          }
+
+          return yield* new ConfigurationError({ message: 'Artifact publish failed.' })
         }
       }
-    }
 
-    throw lastError instanceof Error ? lastError : new Error('Artifact publish failed.')
-  }
+      if (lastError instanceof Error) {
+        return yield* Effect.fail(lastError)
+      }
 
-  async getArtifactRecord(artifactId: RecordIdInput): Promise<ArtifactRecord | null> {
-    return await databaseService.findOne(
-      TABLES.ARTIFACT,
-      { id: ensureRecordId(artifactId, TABLES.ARTIFACT) },
-      ArtifactRecordSchema,
-    )
-  }
+      return yield* new ConfigurationError({ message: 'Artifact publish failed.' })
+    })
+
+  const getArtifactRecordEffect = (artifactId: RecordIdInput) =>
+    db
+      .findOne(TABLES.ARTIFACT, { id: ensureRecordId(artifactId, TABLES.ARTIFACT) }, ArtifactRecordSchema)
+      .pipe(
+        Effect.mapError(
+          (cause) =>
+            new DatabaseError({
+              message: `Failed to load artifact ${recordIdToString(artifactId, TABLES.ARTIFACT)}.`,
+              cause,
+            }),
+        ),
+      )
 
-  async listArtifacts(params: {
+  const listArtifactsEffect = (params: {
     organizationId: RecordIdInput
     canonicalKey?: string
     status?: ArtifactStatus
     includeNonActive?: boolean
     sourceThreadId?: RecordIdInput
     limit?: number
-  }): Promise<ArtifactRecord[]> {
-    const records = await databaseService.findMany(
-      TABLES.ARTIFACT,
-      {
-        organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-        ...(params.canonicalKey ? { canonicalKey: params.canonicalKey } : {}),
-        ...(params.sourceThreadId ? { sourceThreadId: ensureRecordId(params.sourceThreadId, TABLES.THREAD) } : {}),
-      },
-      ArtifactRecordSchema,
-      { orderBy: 'createdAt', orderDir: 'DESC', ...(params.limit ? { limit: params.limit } : {}) },
-    )
-
-    if (params.status) {
-      return records.filter((record) => record.status === params.status)
-    }
+  }) =>
+    Effect.gen(function* () {
+      const records = yield* db
+        .findMany(
+          TABLES.ARTIFACT,
+          {
+            organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
+            ...(params.canonicalKey ? { canonicalKey: params.canonicalKey } : {}),
+            ...(params.sourceThreadId ? { sourceThreadId: ensureRecordId(params.sourceThreadId, TABLES.THREAD) } : {}),
+          },
+          ArtifactRecordSchema,
+          { orderBy: 'createdAt', orderDir: 'DESC', ...(params.limit ? { limit: params.limit } : {}) },
+        )
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new DatabaseError({
+                message: `Failed to list artifacts for organization ${recordIdToString(params.organizationId, TABLES.ORGANIZATION)}.`,
+                cause,
+              }),
+          ),
+        )
 
-    if (params.includeNonActive) {
-      return records
-    }
+      if (params.status) {
+        return records.filter((record) => record.status === params.status)
+      }
 
-    return records.filter((record) => record.status === 'active')
-  }
+      if (params.includeNonActive) {
+        return records
+      }
 
-  async getArtifact(artifactId: RecordIdInput): Promise<GetArtifactResult> {
-    const artifact = await this.getArtifactRecord(artifactId)
-    if (!artifact) {
-      throw new Error(`Artifact not found: ${recordIdToString(artifactId, TABLES.ARTIFACT)}`)
-    }
+      return records.filter((record) => record.status === 'active')
+    })
 
-    const [content, versions, backlinks] = await Promise.all([
-      generatedDocumentStorageService.readTextArtifact(artifact.storageKey),
-      this.listArtifacts({
-        organizationId: artifact.organizationId,
-        canonicalKey: artifact.canonicalKey,
-        includeNonActive: true,
-      }),
-      this.listBacklinks(artifact),
-    ])
-
-    return GetArtifactResultSchema.parse({ artifact, content, versions: versions.map(toVersionSummary), backlinks })
-  }
+  const getArtifactEffect = (artifactId: RecordIdInput) =>
+    Effect.gen(function* () {
+      const artifact = yield* getArtifactRecordEffect(artifactId)
+      if (!artifact) {
+        return yield* new NotFoundError({
+          resource: TABLES.ARTIFACT,
+          id: recordIdToString(artifactId, TABLES.ARTIFACT),
+          message: `Artifact not found: ${recordIdToString(artifactId, TABLES.ARTIFACT)}`,
+        })
+      }
 
-  async listBacklinks(artifact: Pick<ArtifactRecord, 'id' | 'organizationId'>): Promise<ArtifactRecord[]> {
-    const artifactId = recordIdToString(artifact.id, TABLES.ARTIFACT)
-    const records = await databaseService.queryMany(
-      new BoundQuery(
-        `SELECT * FROM ${TABLES.ARTIFACT} WHERE organizationId = $organizationId AND references[*].targetId CONTAINS $targetId`,
-        { organizationId: ensureRecordId(artifact.organizationId, TABLES.ORGANIZATION), targetId: artifactId },
-      ),
-      ArtifactRecordSchema,
-    )
-    return records
+      const [content, versions, backlinks] = yield* Effect.all([
+        storage
+          .readTextArtifact(artifact.storageKey)
+          .pipe(
+            Effect.mapError(
+              (cause) =>
+                new DatabaseError({ message: `Failed to read artifact content for ${artifact.canonicalKey}.`, cause }),
+            ),
+          ),
+        listArtifactsEffect({
+          organizationId: artifact.organizationId,
+          canonicalKey: artifact.canonicalKey,
+          includeNonActive: true,
+        }),
+        listBacklinksEffect(artifact),
+      ])
+
+      return GetArtifactResultSchema.parse({ artifact, content, versions: versions.map(toVersionSummary), backlinks })
+    })
+
+  const listBacklinksEffect = (artifact: Pick<ArtifactRecord, 'id' | 'organizationId'>) =>
+    db
+      .queryMany(
+        new BoundQuery(
+          `SELECT * FROM ${TABLES.ARTIFACT} WHERE organizationId = $organizationId AND references[*].targetId CONTAINS $targetId`,
+          {
+            organizationId: ensureRecordId(artifact.organizationId, TABLES.ORGANIZATION),
+            targetId: recordIdToString(artifact.id, TABLES.ARTIFACT),
+          },
+        ),
+        ArtifactRecordSchema,
+      )
+      .pipe(
+        Effect.mapError(
+          (cause) =>
+            new DatabaseError({
+              message: `Failed to load backlinks for ${recordIdToString(artifact.id, TABLES.ARTIFACT)}.`,
+              cause,
+            }),
+        ),
+      )
+
+  return {
+    publishArtifactInTransaction: (
+      params: PublishArtifactArgs,
+      tx: DatabaseTransaction,
+      options?: PublishArtifactTransactionOptions,
+    ) => publishArtifactInTransactionEffect(params, tx, options),
+    publishArtifact: (params: PublishArtifactArgs) => publishArtifactEffect(params),
+    getArtifactRecord: (artifactId: RecordIdInput) => getArtifactRecordEffect(artifactId),
+    listArtifacts: (params: {
+      organizationId: RecordIdInput
+      canonicalKey?: string
+      status?: ArtifactStatus
+      includeNonActive?: boolean
+      sourceThreadId?: RecordIdInput
+      limit?: number
+    }) => listArtifactsEffect(params),
+    getArtifact: (artifactId: RecordIdInput) => getArtifactEffect(artifactId),
+    listBacklinks: (artifact: Pick<ArtifactRecord, 'id' | 'organizationId'>) => listBacklinksEffect(artifact),
   }
 }
 
-export const artifactService = new ArtifactService()
+export class ArtifactServiceTag extends Context.Service<ArtifactServiceTag, ReturnType<typeof makeArtifactService>>()(
+  'ArtifactService',
+) {}
+
+export const ArtifactServiceLive = Layer.effect(
+  ArtifactServiceTag,
+  Effect.gen(function* () {
+    const db = yield* DatabaseServiceTag
+    const storage = yield* GeneratedDocumentStorageServiceTag
+    return makeArtifactService({ db, storage })
+  }),
+)