@lota-sdk/core 0.4.8 → 0.4.9

package/src/services/user.service.ts

@@ -1,56 +1,106 @@
 import type { SdkUser, SdkUserRecord } from '@lota-sdk/shared'
 import { sdkUserRecordSchema, sdkUserSchema } from '@lota-sdk/shared'
+import { Context, Schema, Effect, Layer } from 'effect'
 
-import { BaseService } from '../db/base.service'
 import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdInput } from '../db/record-id'
-import { databaseService } from '../db/service'
+import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
+import { NotFoundError } from '../effect/errors'
+import { DatabaseServiceTag } from '../effect/services'
 import { toIsoDateTimeString } from '../utils/date-time'
 
-class UserService extends BaseService<typeof sdkUserRecordSchema> {
-  constructor() {
-    super(TABLES.USER, sdkUserRecordSchema)
-  }
+function toPublic(record: SdkUserRecord): SdkUser {
+  return sdkUserSchema.parse({
+    id: recordIdToString(ensureRecordId(record.id as RecordIdInput, TABLES.USER), TABLES.USER),
+    name: record.name,
+    email: record.email,
+    createdAt: toIsoDateTimeString(record.createdAt),
+    updatedAt: toIsoDateTimeString(record.updatedAt),
+  })
+}
 
-  toPublic(record: SdkUserRecord): SdkUser {
-    return sdkUserSchema.parse({
-      id: recordIdToString(ensureRecordId(record.id as RecordIdInput, TABLES.USER), TABLES.USER),
-      name: record.name,
-      email: record.email,
-      createdAt: toIsoDateTimeString(record.createdAt),
-      updatedAt: toIsoDateTimeString(record.updatedAt),
-    })
-  }
+function userNotFoundError(userId: RecordIdInput): NotFoundError {
+  return new NotFoundError({
+    resource: TABLES.USER,
+    id: recordIdToString(userId, TABLES.USER),
+    message: `Record not found in ${TABLES.USER}: ${recordIdToString(userId, TABLES.USER)}`,
+  })
+}
+
+class UserServiceError extends Schema.TaggedErrorClass<UserServiceError>()('UserServiceError', {
+  operation: Schema.String,
+  cause: Schema.Defect,
+}) {}
+
+function toUserServiceError(operation: string, cause: unknown): UserServiceError {
+  return new UserServiceError({ operation, cause })
+}
 
-  async upsertUser(params: { id: RecordIdInput; name: string; email: string }): Promise<SdkUser> {
+export function makeUserService(db: SurrealDBService) {
+  function upsertUserEffect(params: { id: RecordIdInput; name: string; email: string }) {
     const userRef = ensureRecordId(params.id, TABLES.USER)
-    const record = await databaseService.upsert(
-      TABLES.USER,
-      userRef,
-      { name: params.name, email: params.email },
-      sdkUserRecordSchema,
+    return db.upsert(TABLES.USER, userRef, { name: params.name, email: params.email }, sdkUserRecordSchema).pipe(
+      Effect.mapError((cause) => toUserServiceError('upsertUser', cause)),
+      Effect.map(toPublic),
     )
-    return this.toPublic(record)
   }
 
-  async getUser(userId: RecordIdInput): Promise<SdkUser> {
-    return this.toPublic(await this.getById(ensureRecordId(userId, TABLES.USER)))
+  function getUserEffect(userId: RecordIdInput) {
+    return db.findOne(TABLES.USER, { id: ensureRecordId(userId, TABLES.USER) }, sdkUserRecordSchema).pipe(
+      Effect.mapError((cause) => toUserServiceError('getUser', cause)),
+      Effect.flatMap((record) => (record ? Effect.succeed(record) : Effect.fail(userNotFoundError(userId)))),
+      Effect.map(toPublic),
+    )
   }
 
-  async listUsers(): Promise<SdkUser[]> {
-    return (await this.findAll({}, { orderBy: 'createdAt', orderDir: 'ASC' })).map((record) => this.toPublic(record))
+  function listUsersEffect() {
+    return db.findMany(TABLES.USER, {}, sdkUserRecordSchema, { orderBy: 'createdAt', orderDir: 'ASC' }).pipe(
+      Effect.mapError((cause) => toUserServiceError('listUsers', cause)),
+      Effect.map((records) => records.map(toPublic)),
+    )
   }
 
-  async updateUser(userId: RecordIdInput, params: { name?: string; email?: string }): Promise<SdkUser> {
-    return this.toPublic(await this.update(ensureRecordId(userId, TABLES.USER), params))
+  function updateUserEffect(userId: RecordIdInput, params: { name?: string; email?: string }) {
+    return db.update(TABLES.USER, ensureRecordId(userId, TABLES.USER), params, sdkUserRecordSchema).pipe(
+      Effect.mapError((cause) => toUserServiceError('updateUser', cause)),
+      Effect.flatMap((updated) => (updated ? Effect.succeed(updated) : Effect.fail(userNotFoundError(userId)))),
+      Effect.map(toPublic),
+    )
   }
 
-  async deleteUser(userId: RecordIdInput): Promise<void> {
+  function deleteUserEffect(userId: RecordIdInput) {
     const userRef = ensureRecordId(userId, TABLES.USER)
-    await databaseService.deleteWhere(TABLES.ORGANIZATION_MEMBER, { in: userRef })
-    await this.delete(userRef)
+    return Effect.gen(function* () {
+      yield* db
+        .deleteWhere(TABLES.ORGANIZATION_MEMBER, { in: userRef })
+        .pipe(Effect.mapError((cause) => toUserServiceError('deleteUser.deleteMemberships', cause)))
+      const deleted = yield* db
+        .deleteById(TABLES.USER, userRef)
+        .pipe(Effect.mapError((cause) => toUserServiceError('deleteUser.deleteUser', cause)))
+      if (!deleted) {
+        return yield* userNotFoundError(userId)
+      }
+    })
+  }
+
+  return {
+    upsertUser: upsertUserEffect,
+    getUser: getUserEffect,
+    listUsers: listUsersEffect,
+    updateUser: updateUserEffect,
+    deleteUser: deleteUserEffect,
   }
 }
 
-export const userService = new UserService()
+export class UserServiceTag extends Context.Service<UserServiceTag, ReturnType<typeof makeUserService>>()(
+  'UserService',
+) {}
+
+export const UserServiceLive = Layer.effect(
+  UserServiceTag,
+  Effect.gen(function* () {
+    const db = yield* DatabaseServiceTag
+    return makeUserService(db)
+  }),
+)

package/src/services/write-intent-validator.service.ts

@@ -1,6 +1,8 @@
 import type { PlanDataSchema, PlanNodeSpec, PlanSchemaRegistry, WriteIntent } from '@lota-sdk/shared'
+import { Context, Layer } from 'effect'
 
-import { validateSchemaValue } from './plan-validator.service'
+import { nowIsoDateTimeString } from '../utils/date-time'
+import { validateSchemaValue } from './plan/plan-validator.service'
 
 export interface WriteValidationIssue {
   code: string
@@ -15,19 +17,51 @@ export interface WriteValidationResult {
   validatedAt: string
 }
 
-class WriteIntentValidatorService {
-  validate(params: {
-    intent: WriteIntent
-    nodeSpec: PlanNodeSpec
-    schemaRegistry: PlanSchemaRegistry
-    existingDeliverables: Map<string, unknown>
-  }): WriteValidationResult {
-    const issues: WriteValidationIssue[] = []
-    const { intent, nodeSpec, schemaRegistry, existingDeliverables } = params
+function buildWriteValidationResult(issues: WriteValidationIssue[]): WriteValidationResult {
+  const hasFailed = issues.length > 0
+  return {
+    status: hasFailed ? 'fail' : 'pass',
+    issues,
+    ...(hasFailed ? { suggestion: issues.map((i) => i.message).join('; ') } : {}),
+    validatedAt: nowIsoDateTimeString(),
+  }
+}
+
+export function makeWriteIntentValidatorService() {
+  return {
+    validate(params: {
+      intent: WriteIntent
+      nodeSpec: PlanNodeSpec
+      schemaRegistry: PlanSchemaRegistry
+      existingDeliverables: Map<string, unknown>
+    }): WriteValidationResult {
+      const issues: WriteValidationIssue[] = []
+      const { intent, nodeSpec, schemaRegistry, existingDeliverables } = params
+
+      if (intent.targetPath.startsWith('structuredOutput')) {
+        if (nodeSpec.outputSchemaRef) {
+          const schema = schemaRegistry[nodeSpec.outputSchemaRef] as PlanDataSchema | undefined
+          if (schema) {
+            const schemaIssues = validateSchemaValue({ schema, value: intent.payload, path: intent.targetPath })
+            for (const message of schemaIssues) {
+              issues.push({ code: 'schema_validation_failed', message })
+            }
+          }
+        }
+        return buildWriteValidationResult(issues)
+      }
 
-    if (intent.targetPath.startsWith('structuredOutput')) {
-      if (nodeSpec.outputSchemaRef) {
-        const schema = schemaRegistry[nodeSpec.outputSchemaRef] as PlanDataSchema | undefined
+      const deliverable = nodeSpec.deliverables.find((d) => d.name === intent.targetPath)
+      if (!deliverable) {
+        issues.push({
+          code: 'unknown_deliverable',
+          message: `"${intent.targetPath}" does not match any declared deliverable.`,
+        })
+        return buildWriteValidationResult(issues)
+      }
+
+      if (deliverable.schemaRef) {
+        const schema = schemaRegistry[deliverable.schemaRef] as PlanDataSchema | undefined
         if (schema) {
           const schemaIssues = validateSchemaValue({ schema, value: intent.payload, path: intent.targetPath })
           for (const message of schemaIssues) {
@@ -35,47 +69,25 @@ class WriteIntentValidatorService {
           }
         }
       }
-      return this.buildResult(issues)
-    }
-
-    const deliverable = nodeSpec.deliverables.find((d) => d.name === intent.targetPath)
-    if (!deliverable) {
-      issues.push({
-        code: 'unknown_deliverable',
-        message: `"${intent.targetPath}" does not match any declared deliverable.`,
-      })
-      return this.buildResult(issues)
-    }
 
-    if (deliverable.schemaRef) {
-      const schema = schemaRegistry[deliverable.schemaRef] as PlanDataSchema | undefined
-      if (schema) {
-        const schemaIssues = validateSchemaValue({ schema, value: intent.payload, path: intent.targetPath })
-        for (const message of schemaIssues) {
-          issues.push({ code: 'schema_validation_failed', message })
-        }
+      if (intent.action === 'update' && !existingDeliverables.has(intent.targetPath)) {
+        issues.push({
+          code: 'update_target_not_found',
+          message: `Cannot update "${intent.targetPath}" — no prior write exists.`,
+        })
       }
-    }
-
-    if (intent.action === 'update' && !existingDeliverables.has(intent.targetPath)) {
-      issues.push({
-        code: 'update_target_not_found',
-        message: `Cannot update "${intent.targetPath}" — no prior write exists.`,
-      })
-    }
 
-    return this.buildResult(issues)
-  }
-
-  private buildResult(issues: WriteValidationIssue[]): WriteValidationResult {
-    const hasFailed = issues.length > 0
-    return {
-      status: hasFailed ? 'fail' : 'pass',
-      issues,
-      ...(hasFailed ? { suggestion: issues.map((i) => i.message).join('; ') } : {}),
-      validatedAt: new Date().toISOString(),
-    }
+      return buildWriteValidationResult(issues)
+    },
   }
 }
 
-export const writeIntentValidatorService = new WriteIntentValidatorService()
+export class WriteIntentValidatorServiceTag extends Context.Service<
+  WriteIntentValidatorServiceTag,
+  ReturnType<typeof makeWriteIntentValidatorService>
+>()('WriteIntentValidatorService') {}
+
+export const WriteIntentValidatorServiceLive = Layer.succeed(
+  WriteIntentValidatorServiceTag,
+  makeWriteIntentValidatorService(),
+)

package/src/storage/attachment-parser.ts

@@ -1,9 +1,25 @@
 import { SUPPORTED_ATTACHMENT_MIME_TYPES, getAttachmentExtension } from '@lota-sdk/shared'
+import { Schema, Effect } from 'effect'
 import mammoth from 'mammoth'
 import { PDFParse } from 'pdf-parse'
 
 const READ_FILE_PARTS_CHARS_PER_PAGE = 3500
 
+class AttachmentParserError extends Schema.TaggedErrorClass<AttachmentParserError>()('AttachmentParserError', {
+  message: Schema.String,
+  cause: Schema.Defect,
+}) {}
+
+function tryAttachmentPromise<A>(
+  message: string,
+  thunk: () => PromiseLike<A>,
+): Effect.Effect<A, AttachmentParserError> {
+  return Effect.tryPromise({
+    try: () => Promise.resolve(thunk()),
+    catch: (cause) => new AttachmentParserError({ message, cause }),
+  })
+}
+
 export function normalizeExtractedText(value: string): string {
   return value.replaceAll('\u0000', '').replace(/\r\n/g, '\n').trim()
 }
@@ -29,44 +45,70 @@ export function isTextAttachmentFile(file: File): boolean {
   return ext === 'txt' || ext === 'md' || ext === 'markdown'
 }
 
-export async function extractPdfPages(file: File): Promise<string[]> {
-  const parser = new PDFParse({ data: new Uint8Array(await file.arrayBuffer()) })
-  try {
-    const info = await parser.getInfo()
-    const textResult = await parser.getText()
-
-    const pageTextByNumber = new Map<number, string>()
-    for (const page of textResult.pages) {
-      pageTextByNumber.set(page.num, normalizeExtractedText(page.text))
-    }
-
-    const pages: string[] = []
-    for (let pageNumber = 1; pageNumber <= info.total; pageNumber += 1) {
-      pages.push(pageTextByNumber.get(pageNumber) ?? '')
-    }
-    return pages
-  } finally {
-    await parser.destroy()
-  }
+export function extractPdfPages(file: File): Promise<string[]> {
+  return Effect.runPromise(
+    Effect.gen(function* () {
+      const buffer = yield* tryAttachmentPromise('Failed to read PDF attachment buffer.', () => file.arrayBuffer())
+      const parser = new PDFParse({ data: new Uint8Array(buffer) })
+
+      return yield* Effect.gen(function* () {
+        const info = yield* tryAttachmentPromise('Failed to read PDF attachment metadata.', () => parser.getInfo())
+        const textResult = yield* tryAttachmentPromise('Failed to extract PDF attachment text.', () => parser.getText())
+        const pageTextByNumber = new Map<number, string>()
+        for (const page of textResult.pages) {
+          pageTextByNumber.set(page.num, normalizeExtractedText(page.text))
+        }
+
+        const pages: string[] = []
+        for (let pageNumber = 1; pageNumber <= info.total; pageNumber += 1) {
+          pages.push(pageTextByNumber.get(pageNumber) ?? '')
+        }
+        return pages
+      }).pipe(
+        Effect.ensuring(
+          tryAttachmentPromise('Failed to destroy PDF parser.', () => parser.destroy()).pipe(
+            Effect.orDie,
+            Effect.asVoid,
+          ),
+        ),
+      )
+    }),
+  )
 }
 
-export async function extractDocxText(file: File): Promise<string> {
-  const buffer = Buffer.from(await file.arrayBuffer())
-  const result = await mammoth.extractRawText({ buffer })
-  return normalizeExtractedText(result.value)
+export function extractDocxText(file: File): Promise<string> {
+  return Effect.runPromise(
+    Effect.gen(function* () {
+      const arrayBuffer = yield* tryAttachmentPromise('Failed to read DOCX attachment buffer.', () =>
+        file.arrayBuffer(),
+      )
+      const result = yield* tryAttachmentPromise('Failed to extract DOCX attachment text.', () =>
+        mammoth.extractRawText({ buffer: Buffer.from(arrayBuffer) }),
+      )
+      return normalizeExtractedText(result.value)
+    }),
+  )
 }
 
-export async function extractAttachmentText(file: File): Promise<string> {
+export function extractAttachmentText(file: File): Promise<string> {
   if (isTextAttachmentFile(file)) {
-    return normalizeExtractedText(await file.text())
+    return Effect.runPromise(
+      tryAttachmentPromise('Failed to read text attachment.', () => file.text()).pipe(
+        Effect.map(normalizeExtractedText),
+      ),
+    )
   }
   if (isPdfAttachmentFile(file)) {
-    return normalizeExtractedText((await extractPdfPages(file)).join('\n\n'))
+    return Effect.runPromise(
+      tryAttachmentPromise('Failed to extract PDF attachment text.', () => extractPdfPages(file)).pipe(
+        Effect.map((pages) => normalizeExtractedText(pages.join('\n\n'))),
+      ),
+    )
   }
   if (isDocxAttachmentFile(file)) {
     return extractDocxText(file)
   }
-  return ''
+  return Promise.resolve('')
 }
 
 export function splitExtractedTextIntoPages(extractedText: string): string[] {