@lota-sdk/core 0.4.8 → 0.4.10

package/src/services/organization.service.ts

@@ -1,117 +1,193 @@
-import { recordIdSchema, recordIdStringSchema } from '@lota-sdk/shared'
-import { z } from 'zod'
+import { sdkOrganizationRecordSchema, sdkOrganizationSchema } from '@lota-sdk/shared'
+import type { SdkOrganization, SdkOrganizationRecord } 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, RecordIdRef } 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, toOptionalIsoDateTimeString } from '../utils/date-time'
 
-const organizationRecordSchema = z.object({
-  id: recordIdSchema,
-  name: z.string(),
-  regularChatDigestLastThreadCursorCreatedAt: z.coerce.date().optional(),
-  regularChatDigestLastThreadCursorId: z.string().optional(),
-  skillExtractionLastCursorId: z.string().optional(),
-  skillExtractionLastCursorCreatedAt: z.coerce.date().optional(),
-  createdAt: z.coerce.date(),
-  updatedAt: z.coerce.date(),
-})
-
-const sdkOrganizationSchema = z.object({
-  id: recordIdStringSchema,
-  name: z.string(),
-  regularChatDigestLastThreadCursorCreatedAt: z.iso.datetime().nullable().optional(),
-  regularChatDigestLastThreadCursorId: z.string().nullable().optional(),
-  skillExtractionLastCursorId: z.string().nullable().optional(),
-  skillExtractionLastCursorCreatedAt: z.iso.datetime().nullable().optional(),
-  createdAt: z.iso.datetime(),
-  updatedAt: z.iso.datetime(),
-})
-
-export type SdkOrganizationRecord = z.infer<typeof organizationRecordSchema>
-export type SdkOrganization = z.infer<typeof sdkOrganizationSchema>
+export type { SdkOrganization, SdkOrganizationRecord }
 
 interface BackgroundCursor {
   createdAt: Date
   id: string
 }
 
+class OrganizationServiceError extends Schema.TaggedErrorClass<OrganizationServiceError>()('OrganizationServiceError', {
+  operation: Schema.String,
+  cause: Schema.Defect,
+}) {}
+
 function toOptionalCursorTimestamp(value: unknown): string | null {
   return toOptionalIsoDateTimeString(value) ?? null
 }
 
-class OrganizationService extends BaseService<typeof organizationRecordSchema> {
-  constructor() {
-    super(TABLES.ORGANIZATION, organizationRecordSchema)
-  }
+function toPublicEffect(record: SdkOrganizationRecord): Effect.Effect<SdkOrganization, OrganizationServiceError> {
+  return Effect.try({
+    try: () =>
+      sdkOrganizationSchema.parse({
+        id: recordIdToString(ensureRecordId(record.id as RecordIdInput, TABLES.ORGANIZATION), TABLES.ORGANIZATION),
+        name: record.name,
+        regularChatDigestLastThreadCursorCreatedAt: toOptionalCursorTimestamp(
+          record.regularChatDigestLastThreadCursorCreatedAt,
+        ),
+        regularChatDigestLastThreadCursorId: record.regularChatDigestLastThreadCursorId ?? null,
+        skillExtractionLastCursorId: record.skillExtractionLastCursorId ?? null,
+        skillExtractionLastCursorCreatedAt: toOptionalCursorTimestamp(record.skillExtractionLastCursorCreatedAt),
+        createdAt: toIsoDateTimeString(record.createdAt),
+        updatedAt: toIsoDateTimeString(record.updatedAt),
+      }),
+    catch: (cause) => toOrganizationServiceError('toPublic', cause),
+  })
+}
 
-  toPublic(record: SdkOrganizationRecord): SdkOrganization {
-    return sdkOrganizationSchema.parse({
-      id: recordIdToString(ensureRecordId(record.id as RecordIdInput, TABLES.ORGANIZATION), TABLES.ORGANIZATION),
-      name: record.name,
-      regularChatDigestLastThreadCursorCreatedAt: toOptionalCursorTimestamp(
-        record.regularChatDigestLastThreadCursorCreatedAt,
-      ),
-      regularChatDigestLastThreadCursorId: record.regularChatDigestLastThreadCursorId ?? null,
-      skillExtractionLastCursorId: record.skillExtractionLastCursorId ?? null,
-      skillExtractionLastCursorCreatedAt: toOptionalCursorTimestamp(record.skillExtractionLastCursorCreatedAt),
-      createdAt: toIsoDateTimeString(record.createdAt),
-      updatedAt: toIsoDateTimeString(record.updatedAt),
-    })
-  }
+function organizationNotFoundError(organizationId: RecordIdInput): NotFoundError {
+  return new NotFoundError({
+    resource: TABLES.ORGANIZATION,
+    id: recordIdToString(organizationId, TABLES.ORGANIZATION),
+    message: `Record not found in ${TABLES.ORGANIZATION}: ${recordIdToString(organizationId, TABLES.ORGANIZATION)}`,
+  })
+}
+
+function toOrganizationServiceError(operation: string, cause: unknown): OrganizationServiceError {
+  return new OrganizationServiceError({ operation, cause })
+}
 
-  async createOrganization(params: { name: string }): Promise<SdkOrganization> {
-    return this.toPublic(await this.create({ name: params.name }))
+export function makeOrganizationService(db: SurrealDBService) {
+  function createOrganization(params: { name: string }) {
+    return db.create(TABLES.ORGANIZATION, { name: params.name }, sdkOrganizationRecordSchema).pipe(
+      Effect.mapError((cause) => toOrganizationServiceError('createOrganization', cause)),
+      Effect.flatMap(toPublicEffect),
+    )
   }
 
-  async upsertOrganization(params: { id: RecordIdInput; name: string }): Promise<SdkOrganization> {
+  function upsertOrganization(params: { id: RecordIdInput; name: string }) {
     const organizationRef = ensureRecordId(params.id, TABLES.ORGANIZATION)
-    const record = await databaseService.upsert(
-      TABLES.ORGANIZATION,
-      organizationRef,
-      { name: params.name },
-      organizationRecordSchema,
+    return db.upsert(TABLES.ORGANIZATION, organizationRef, { name: params.name }, sdkOrganizationRecordSchema).pipe(
+      Effect.mapError((cause) => toOrganizationServiceError('upsertOrganization', cause)),
+      Effect.flatMap(toPublicEffect),
     )
-    return this.toPublic(record)
   }
 
-  async listOrganizations(): Promise<SdkOrganization[]> {
-    return (await this.findAll({}, { orderBy: 'createdAt', orderDir: 'ASC' })).map((record) => this.toPublic(record))
+  function listOrganizations() {
+    return db
+      .findMany(TABLES.ORGANIZATION, {}, sdkOrganizationRecordSchema, { orderBy: 'createdAt', orderDir: 'ASC' })
+      .pipe(
+        Effect.mapError((cause) => toOrganizationServiceError('listOrganizations', cause)),
+        Effect.flatMap((records) => Effect.forEach(records, toPublicEffect)),
+      )
   }
 
-  async getOrganization(organizationId: RecordIdInput): Promise<SdkOrganization> {
-    return this.toPublic(await this.getById(ensureRecordId(organizationId, TABLES.ORGANIZATION)))
+  function getOrganizationRecord(organizationId: RecordIdRef) {
+    return db
+      .findOne(
+        TABLES.ORGANIZATION,
+        { id: ensureRecordId(organizationId, TABLES.ORGANIZATION) },
+        sdkOrganizationRecordSchema,
+      )
+      .pipe(
+        Effect.mapError((cause) => toOrganizationServiceError('getOrganizationRecord', cause)),
+        Effect.flatMap((record) =>
+          record ? Effect.succeed(record) : Effect.fail(organizationNotFoundError(organizationId)),
+        ),
+      )
   }
 
-  async getOrganizationRecord(organizationId: RecordIdRef): Promise<SdkOrganizationRecord> {
-    return this.getById(ensureRecordId(organizationId, TABLES.ORGANIZATION))
+  function getOrganization(organizationId: RecordIdInput) {
+    return getOrganizationRecord(ensureRecordId(organizationId, TABLES.ORGANIZATION)).pipe(
+      Effect.flatMap(toPublicEffect),
+    )
   }
 
-  async updateOrganization(organizationId: RecordIdInput, params: { name: string }): Promise<SdkOrganization> {
-    return this.toPublic(await this.update(ensureRecordId(organizationId, TABLES.ORGANIZATION), { name: params.name }))
+  function updateOrganization(organizationId: RecordIdInput, params: { name: string }) {
+    return db
+      .update(
+        TABLES.ORGANIZATION,
+        ensureRecordId(organizationId, TABLES.ORGANIZATION),
+        { name: params.name },
+        sdkOrganizationRecordSchema,
+      )
+      .pipe(
+        Effect.mapError((cause) => toOrganizationServiceError('updateOrganization', cause)),
+        Effect.flatMap((updated) =>
+          updated ? Effect.succeed(updated) : Effect.fail(organizationNotFoundError(organizationId)),
+        ),
+        Effect.flatMap(toPublicEffect),
+      )
   }
 
-  async deleteOrganization(organizationId: RecordIdInput): Promise<void> {
+  function deleteOrganization(organizationId: RecordIdInput) {
     const organizationRef = ensureRecordId(organizationId, TABLES.ORGANIZATION)
-    await databaseService.deleteWhere(TABLES.ORGANIZATION_MEMBER, { out: organizationRef })
-    await this.delete(organizationRef)
+    return Effect.gen(function* () {
+      yield* db
+        .deleteWhere(TABLES.ORGANIZATION_MEMBER, { out: organizationRef })
+        .pipe(Effect.mapError((cause) => toOrganizationServiceError('deleteOrganization.deleteMembers', cause)))
+      const deleted = yield* db
+        .deleteById(TABLES.ORGANIZATION, organizationRef)
+        .pipe(Effect.mapError((cause) => toOrganizationServiceError('deleteOrganization.deleteOrganization', cause)))
+      if (!deleted) {
+        return yield* organizationNotFoundError(organizationId)
+      }
+    })
   }
 
-  async updateRegularChatDigestCursor(organizationId: RecordIdRef, cursor: BackgroundCursor): Promise<void> {
-    await this.update(organizationId, {
-      regularChatDigestLastThreadCursorCreatedAt: cursor.createdAt,
-      regularChatDigestLastThreadCursorId: cursor.id,
-    })
+  function updateRegularChatDigestCursor(organizationId: RecordIdRef, cursor: BackgroundCursor) {
+    return db
+      .update(
+        TABLES.ORGANIZATION,
+        ensureRecordId(organizationId, TABLES.ORGANIZATION),
+        {
+          regularChatDigestLastThreadCursorCreatedAt: cursor.createdAt,
+          regularChatDigestLastThreadCursorId: cursor.id,
+        },
+        sdkOrganizationRecordSchema,
+      )
+      .pipe(
+        Effect.mapError((cause) => toOrganizationServiceError('updateRegularChatDigestCursor', cause)),
+        Effect.flatMap((updated) => (updated ? Effect.void : Effect.fail(organizationNotFoundError(organizationId)))),
+      )
   }
 
-  async updateSkillExtractionCursor(organizationId: RecordIdRef, cursor: BackgroundCursor): Promise<void> {
-    await this.update(organizationId, {
-      skillExtractionLastCursorCreatedAt: cursor.createdAt,
-      skillExtractionLastCursorId: cursor.id,
-    })
+  function updateSkillExtractionCursor(organizationId: RecordIdRef, cursor: BackgroundCursor) {
+    return db
+      .update(
+        TABLES.ORGANIZATION,
+        ensureRecordId(organizationId, TABLES.ORGANIZATION),
+        { skillExtractionLastCursorCreatedAt: cursor.createdAt, skillExtractionLastCursorId: cursor.id },
+        sdkOrganizationRecordSchema,
+      )
+      .pipe(
+        Effect.mapError((cause) => toOrganizationServiceError('updateSkillExtractionCursor', cause)),
+        Effect.flatMap((updated) => (updated ? Effect.void : Effect.fail(organizationNotFoundError(organizationId)))),
+      )
+  }
+
+  return {
+    createOrganization,
+    upsertOrganization,
+    listOrganizations,
+    getOrganization,
+    getOrganizationRecord,
+    updateOrganization,
+    deleteOrganization,
+    updateRegularChatDigestCursor,
+    updateSkillExtractionCursor,
   }
 }
 
-export const organizationService = new OrganizationService()
+export class OrganizationServiceTag extends Context.Service<
+  OrganizationServiceTag,
+  ReturnType<typeof makeOrganizationService>
+>()('@lota-sdk/core/OrganizationService') {}
+
+export const OrganizationServiceLive = Layer.effect(
+  OrganizationServiceTag,
+  Effect.gen(function* () {
+    const db = yield* DatabaseServiceTag
+    return makeOrganizationService(db)
+  }),
+)