@lota-sdk/core 0.4.8 → 0.4.10

package/src/services/node-workspace.service.ts

@@ -1,3 +1,4 @@
+import { isSafePath } from '@lota-sdk/shared'
 import type {
   PlanArtifactSubmission,
   PlanNodeResult,
@@ -6,8 +7,12 @@ import type {
   WriteIntent,
   WriteIntentAction,
 } from '@lota-sdk/shared'
+import { Context, Effect, Layer } from 'effect'
 
 import { serverLogger } from '../config/logger'
+import { BadRequestError } from '../effect/errors'
+import { nowDate } from '../utils/date-time'
+import { cloneToNullProtoRecord, createNullProtoRecord, setPathValue } from '../utils/null-proto-record'
 
 export type WorkspaceEntryValidation = 'validated' | 'unvalidated'
 
@@ -36,121 +41,159 @@ export interface NodeWorkspace {
   deliverables: Map<string, WorkspaceEntry>
 }
 
-class NodeWorkspaceService {
-  initialize(params: {
-    nodeSpec: PlanNodeSpec
-    resolvedInput: Record<string, unknown>
-    inputArtifacts: PlanArtifactSubmission[]
-    schemaRegistry: PlanSchemaRegistry
-  }): NodeWorkspace {
-    const ctx = Object.freeze({
-      resolvedInput: params.resolvedInput,
-      inputArtifacts: params.inputArtifacts,
-      schemaRegistry: params.schemaRegistry,
-      nodeSpec: params.nodeSpec,
-    })
-
-    return {
-      nodeId: params.nodeSpec.id,
-      ctx,
-      work: new Map(),
-      sys: { startedAt: new Date(), correctionCounts: new Map(), writeLog: [] },
-      deliverables: new Map(),
-    }
+function initializeWorkspace(params: {
+  nodeSpec: PlanNodeSpec
+  resolvedInput: Record<string, unknown>
+  inputArtifacts: PlanArtifactSubmission[]
+  schemaRegistry: PlanSchemaRegistry
+}): NodeWorkspace {
+  const ctx = Object.freeze({
+    resolvedInput: params.resolvedInput,
+    inputArtifacts: params.inputArtifacts,
+    schemaRegistry: params.schemaRegistry,
+    nodeSpec: params.nodeSpec,
+  })
+
+  return {
+    nodeId: params.nodeSpec.id,
+    ctx,
+    work: new Map(),
+    sys: { startedAt: nowDate(), correctionCounts: new Map(), writeLog: [] },
+    deliverables: new Map(),
   }
+}
 
-  stageWrite(workspace: NodeWorkspace, intent: WriteIntent, validation: WorkspaceEntryValidation): void {
-    const existing = workspace.deliverables.get(intent.targetPath)
+export function makeNodeWorkspaceService() {
+  const stageWriteEffect = (
+    workspace: NodeWorkspace,
+    intent: WriteIntent,
+    validation: WorkspaceEntryValidation,
+  ): Effect.Effect<void, BadRequestError> =>
+    Effect.gen(function* () {
+      if (!isSafePath(intent.targetPath)) {
+        return yield* new BadRequestError({ message: `Unsafe path "${intent.targetPath}"` })
+      }
+
+      const existing = workspace.deliverables.get(intent.targetPath)
+
+      if (intent.action === 'append' && existing && Array.isArray(existing.payload) && Array.isArray(intent.payload)) {
+        existing.payload = [...(existing.payload as unknown[]), ...intent.payload]
+        existing.action = intent.action
+        existing.validation = validation
+        existing.stagedAt = nowDate()
+      } else {
+        workspace.deliverables.set(intent.targetPath, {
+          targetPath: intent.targetPath,
+          action: intent.action,
+          payload: intent.payload,
+          validation,
+          stagedAt: nowDate(),
+        })
+      }
 
-    if (intent.action === 'append' && existing && Array.isArray(existing.payload) && Array.isArray(intent.payload)) {
-      existing.payload = [...(existing.payload as unknown[]), ...intent.payload]
-      existing.action = intent.action
-      existing.validation = validation
-      existing.stagedAt = new Date()
-    } else {
-      workspace.deliverables.set(intent.targetPath, {
+      workspace.sys.writeLog.push({
         targetPath: intent.targetPath,
         action: intent.action,
-        payload: intent.payload,
-        validation,
-        stagedAt: new Date(),
+        timestamp: nowDate(),
+        result: 'accepted',
       })
-    }
-
-    workspace.sys.writeLog.push({
-      targetPath: intent.targetPath,
-      action: intent.action,
-      timestamp: new Date(),
-      result: 'accepted',
     })
-  }
 
-  finalize(workspace: NodeWorkspace): PlanNodeResult & { isComplete: boolean } {
-    const artifacts: PlanArtifactSubmission[] = []
-    let structuredOutput: Record<string, unknown> | undefined
-    let allValidated = true
-    const requiredNames = new Set(workspace.ctx.nodeSpec.deliverables.filter((d) => d.required).map((d) => d.name))
-    const presentRequired = new Set<string>()
+  const finalizeEffect = (
+    workspace: NodeWorkspace,
+  ): Effect.Effect<PlanNodeResult & { isComplete: boolean }, BadRequestError> =>
+    Effect.gen(function* () {
+      const artifacts: PlanArtifactSubmission[] = []
+      let structuredOutput: Record<string, unknown> | undefined
+      let allValidated = true
+      const requiredNames = new Set(workspace.ctx.nodeSpec.deliverables.filter((d) => d.required).map((d) => d.name))
+      const presentRequired = new Set<string>()
+
+      for (const [targetPath, entry] of workspace.deliverables) {
+        if (entry.validation === 'unvalidated') {
+          allValidated = false
+        }
 
-    for (const [targetPath, entry] of workspace.deliverables) {
-      if (entry.validation === 'unvalidated') {
-        allValidated = false
-      }
+        if (targetPath.startsWith('structuredOutput')) {
+          const subPath = targetPath.replace(/^structuredOutput\.?/, '')
+          if (subPath && !isSafePath(subPath)) {
+            return yield* new BadRequestError({ message: `Unsafe path "${targetPath}"` })
+          }
+
+          if (!structuredOutput) structuredOutput = createNullProtoRecord()
+          if (subPath) {
+            setPathValue(structuredOutput, subPath, entry.payload)
+          } else {
+            structuredOutput =
+              typeof entry.payload === 'object' && entry.payload !== null && !Array.isArray(entry.payload)
+                ? cloneToNullProtoRecord(entry.payload as Record<string, unknown>)
+                : structuredOutput
+          }
+          continue
+        }
 
-      if (targetPath.startsWith('structuredOutput')) {
-        if (!structuredOutput) structuredOutput = {}
-        const subPath = targetPath.replace(/^structuredOutput\.?/, '')
-        if (subPath) {
-          structuredOutput[subPath] = entry.payload
-        } else {
-          structuredOutput =
-            typeof entry.payload === 'object' && entry.payload !== null && !Array.isArray(entry.payload)
-              ? (entry.payload as Record<string, unknown>)
-              : structuredOutput
+        const spec = workspace.ctx.nodeSpec.deliverables.find((d) => d.name === targetPath)
+        if (!spec) {
+          serverLogger.warn`Write to unknown deliverable path "${targetPath}" in node ${workspace.nodeId} — skipping`
+          continue
         }
-        continue
-      }
 
-      const spec = workspace.ctx.nodeSpec.deliverables.find((d) => d.name === targetPath)
-      if (!spec) {
-        serverLogger.warn`Write to unknown deliverable path "${targetPath}" in node ${workspace.nodeId} — skipping`
-        continue
-      }
+        if (requiredNames.has(targetPath)) {
+          presentRequired.add(targetPath)
+        }
 
-      if (requiredNames.has(targetPath)) {
-        presentRequired.add(targetPath)
+        artifacts.push({
+          name: spec.name,
+          kind: spec.kind,
+          description: spec.description,
+          payload:
+            typeof entry.payload === 'string'
+              ? { content: entry.payload }
+              : typeof entry.payload === 'object' && entry.payload !== null
+                ? (entry.payload as Record<string, unknown> | unknown[])
+                : undefined,
+        })
       }
 
-      artifacts.push({
-        name: spec.name,
-        kind: spec.kind,
-        description: spec.description,
-        payload:
-          typeof entry.payload === 'string'
-            ? { content: entry.payload }
-            : typeof entry.payload === 'object' && entry.payload !== null
-              ? (entry.payload as Record<string, unknown> | unknown[])
-              : undefined,
-      })
-    }
-
-    const allRequiredPresent = requiredNames.size === presentRequired.size
-    const isComplete = allRequiredPresent && allValidated
+      const allRequiredPresent = requiredNames.size === presentRequired.size
+      const isComplete = allRequiredPresent && allValidated
 
-    return {
-      notes: isComplete ? 'All deliverables completed.' : 'Partial deliverables completed.',
-      structuredOutput,
-      artifacts,
-      isComplete,
-    }
-  }
+      return {
+        notes: isComplete ? 'All deliverables completed.' : 'Partial deliverables completed.',
+        structuredOutput,
+        artifacts,
+        isComplete,
+      }
+    })
 
-  cleanup(workspace: NodeWorkspace): void {
-    workspace.work.clear()
-    workspace.deliverables.clear()
-    workspace.sys.writeLog.length = 0
-    workspace.sys.correctionCounts.clear()
+  return {
+    initialize(params: {
+      nodeSpec: PlanNodeSpec
+      resolvedInput: Record<string, unknown>
+      inputArtifacts: PlanArtifactSubmission[]
+      schemaRegistry: PlanSchemaRegistry
+    }): NodeWorkspace {
+      return initializeWorkspace(params)
+    },
+
+    stageWrite: stageWriteEffect,
+
+    finalize: finalizeEffect,
+
+    cleanup(workspace: NodeWorkspace): void {
+      workspace.work.clear()
+      workspace.deliverables.clear()
+      workspace.sys.writeLog.length = 0
+      workspace.sys.correctionCounts.clear()
+    },
   }
 }
 
-export const nodeWorkspaceService = new NodeWorkspaceService()
+export const nodeWorkspaceService = makeNodeWorkspaceService()
+
+export class NodeWorkspaceServiceTag extends Context.Service<
+  NodeWorkspaceServiceTag,
+  ReturnType<typeof makeNodeWorkspaceService>
+>()('@lota-sdk/core/NodeWorkspaceService') {}
+
+export const NodeWorkspaceServiceLive = Layer.sync(NodeWorkspaceServiceTag, () => makeNodeWorkspaceService())

package/src/services/notification.service.ts

@@ -1,4 +1,5 @@
 import type { NotificationSeverity } from '@lota-sdk/shared'
+import { Context, Effect, Layer } from 'effect'
 
 export interface NotificationPayload {
   organizationId: string
@@ -16,24 +17,36 @@ export interface NotificationService {
   notify(payload: NotificationPayload): Promise<void>
   remind(payload: NotificationPayload): Promise<void>
   escalate(payload: NotificationPayload): Promise<void>
+  notifyEffect?(payload: NotificationPayload): Effect.Effect<void, never>
+  remindEffect?(payload: NotificationPayload): Effect.Effect<void, never>
+  escalateEffect?(payload: NotificationPayload): Effect.Effect<void, never>
 }
 
-export class NoOpNotificationService implements NotificationService {
-  async notify(_payload: NotificationPayload): Promise<void> {}
-  async remind(_payload: NotificationPayload): Promise<void> {}
-  async escalate(_payload: NotificationPayload): Promise<void> {}
-}
-
-let _notificationService: NotificationService | null = null
-
-export function configureNotificationService(service: NotificationService | null): void {
-  _notificationService = service
+export function makeNotificationService(): Required<NotificationService> {
+  return {
+    notify(_payload: NotificationPayload): Promise<void> {
+      return Promise.resolve()
+    },
+    remind(_payload: NotificationPayload): Promise<void> {
+      return Promise.resolve()
+    },
+    escalate(_payload: NotificationPayload): Promise<void> {
+      return Promise.resolve()
+    },
+    notifyEffect(_payload: NotificationPayload): Effect.Effect<void, never> {
+      return Effect.void
+    },
+    remindEffect(_payload: NotificationPayload): Effect.Effect<void, never> {
+      return Effect.void
+    },
+    escalateEffect(_payload: NotificationPayload): Effect.Effect<void, never> {
+      return Effect.void
+    },
+  }
 }
 
-export function getNotificationService(): NotificationService {
-  if (_notificationService === null) {
-    throw new Error('Notification service is not configured.')
-  }
+export class NotificationServiceTag extends Context.Service<NotificationServiceTag, NotificationService>()(
+  '@lota-sdk/core/NotificationService',
+) {}
 
-  return _notificationService
-}
+export const NotificationServiceLive = Layer.sync(NotificationServiceTag, () => makeNotificationService())

package/src/services/organization-member.service.ts

@@ -1,10 +1,12 @@
 import { recordIdSchema, recordIdStringSchema } from '@lota-sdk/shared'
+import { Context, Schema, Effect, Layer } from 'effect'
 import { z } from 'zod'
 
-import { BaseService } from '../db/base.service'
 import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdInput, RecordIdRef } from '../db/record-id'
+import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
+import { DatabaseServiceTag } from '../effect/services'
 import { toIsoDateTimeString } from '../utils/date-time'
 
 const organizationMemberRecordSchema = z.object({
@@ -26,96 +28,148 @@ const sdkOrganizationMemberSchema = z.object({
 type SdkOrganizationMemberRecord = z.infer<typeof organizationMemberRecordSchema>
 export type SdkOrganizationMember = z.infer<typeof sdkOrganizationMemberSchema>
 
-class OrganizationMemberService extends BaseService<typeof organizationMemberRecordSchema> {
-  constructor() {
-    super(TABLES.ORGANIZATION_MEMBER, organizationMemberRecordSchema)
-  }
+class OrganizationMemberServiceError extends Schema.TaggedErrorClass<OrganizationMemberServiceError>()(
+  'OrganizationMemberServiceError',
+  { operation: Schema.String, cause: Schema.Defect },
+) {}
 
-  toPublic(record: SdkOrganizationMemberRecord): SdkOrganizationMember {
-    return sdkOrganizationMemberSchema.parse({
-      id: recordIdToString(
-        ensureRecordId(record.id as RecordIdInput, TABLES.ORGANIZATION_MEMBER),
-        TABLES.ORGANIZATION_MEMBER,
-      ),
-      userId: recordIdToString(ensureRecordId(record.in as RecordIdInput, TABLES.USER), TABLES.USER),
-      organizationId: recordIdToString(
-        ensureRecordId(record.out as RecordIdInput, TABLES.ORGANIZATION),
-        TABLES.ORGANIZATION,
-      ),
-      role: record.role,
-      createdAt: toIsoDateTimeString(record.createdAt),
-    })
+function toOrganizationMemberServiceError(operation: string, cause: unknown): OrganizationMemberServiceError {
+  return new OrganizationMemberServiceError({ operation, cause })
+}
+
+function toPublic(record: SdkOrganizationMemberRecord): SdkOrganizationMember {
+  return sdkOrganizationMemberSchema.parse({
+    id: recordIdToString(
+      ensureRecordId(record.id as RecordIdInput, TABLES.ORGANIZATION_MEMBER),
+      TABLES.ORGANIZATION_MEMBER,
+    ),
+    userId: recordIdToString(ensureRecordId(record.in as RecordIdInput, TABLES.USER), TABLES.USER),
+    organizationId: recordIdToString(
+      ensureRecordId(record.out as RecordIdInput, TABLES.ORGANIZATION),
+      TABLES.ORGANIZATION,
+    ),
+    role: record.role,
+    createdAt: toIsoDateTimeString(record.createdAt),
+  })
+}
+
+export function makeOrganizationMemberService(db: SurrealDBService) {
+  function findMembershipRecords(
+    filter: Record<string, unknown>,
+    options?: { limit?: number; orderBy?: string; orderDir?: 'ASC' | 'DESC' },
+  ) {
+    return db
+      .findMany(TABLES.ORGANIZATION_MEMBER, filter, organizationMemberRecordSchema, options)
+      .pipe(Effect.mapError((cause) => toOrganizationMemberServiceError('findMembershipRecords', cause)))
   }
 
-  async addMembership(params: {
-    userId: RecordIdInput
-    organizationId: RecordIdInput
-    role: 'owner' | 'member'
-  }): Promise<SdkOrganizationMember> {
+  function addMembership(params: { userId: RecordIdInput; organizationId: RecordIdInput; role: 'owner' | 'member' }) {
     const userRef = ensureRecordId(params.userId, TABLES.USER)
     const organizationRef = ensureRecordId(params.organizationId, TABLES.ORGANIZATION)
-    const existing = (await this.findAll({ in: userRef, out: organizationRef }, { limit: 1 })).at(0)
-
-    if (existing) {
-      return this.toPublic(await this.update(existing.id, { role: params.role }))
-    }
-
-    const related = await this.databaseService.relate(userRef, TABLES.ORGANIZATION_MEMBER, organizationRef, {
-      role: params.role,
-    })
-    if (!related) {
-      throw new Error(
-        `Failed to create membership for ${recordIdToString(userRef, TABLES.USER)} in ${recordIdToString(
-          organizationRef,
-          TABLES.ORGANIZATION,
-        )}`,
+    return Effect.gen(function* () {
+      const records = yield* findMembershipRecords({ in: userRef, out: organizationRef }, { limit: 1 }).pipe(
+        Effect.mapError((cause) => toOrganizationMemberServiceError('addMembership.findExisting', cause)),
       )
-    }
-
-    const record = organizationMemberRecordSchema.parse(related)
-
-    return this.toPublic(record)
+      const existing = records.at(0)
+
+      if (existing) {
+        const updated = yield* db
+          .update(TABLES.ORGANIZATION_MEMBER, existing.id, { role: params.role }, organizationMemberRecordSchema)
+          .pipe(Effect.mapError((cause) => toOrganizationMemberServiceError('addMembership.update', cause)))
+        if (!updated) {
+          return yield* new OrganizationMemberServiceError({
+            operation: 'addMembership.update',
+            cause: new Error(
+              `Failed to update membership for ${recordIdToString(userRef, TABLES.USER)} in ${recordIdToString(organizationRef, TABLES.ORGANIZATION)}`,
+            ),
+          })
+        }
+        return toPublic(updated)
+      }
+
+      const related = yield* db
+        .relate(userRef, TABLES.ORGANIZATION_MEMBER, organizationRef, { role: params.role })
+        .pipe(Effect.mapError((cause) => toOrganizationMemberServiceError('addMembership.relate', cause)))
+      if (!related) {
+        return yield* new OrganizationMemberServiceError({
+          operation: 'addMembership.relate',
+          cause: new Error(
+            `Failed to create membership for ${recordIdToString(userRef, TABLES.USER)} in ${recordIdToString(organizationRef, TABLES.ORGANIZATION)}`,
+          ),
+        })
+      }
+
+      return toPublic(organizationMemberRecordSchema.parse(related))
+    })
   }
 
-  async listMembershipsForOrganization(organizationId: RecordIdRef): Promise<SdkOrganizationMember[]> {
+  function listMembershipsForOrganization(organizationId: RecordIdRef) {
     const organizationRef = ensureRecordId(organizationId, TABLES.ORGANIZATION)
-    return (await this.findAll({ out: organizationRef }, { orderBy: 'createdAt', orderDir: 'ASC' })).map((record) =>
-      this.toPublic(record),
+    return findMembershipRecords({ out: organizationRef }, { orderBy: 'createdAt', orderDir: 'ASC' }).pipe(
+      Effect.mapError((cause) => toOrganizationMemberServiceError('listMembershipsForOrganization', cause)),
+      Effect.map((records) => records.map(toPublic)),
     )
   }
 
-  async listMembershipsForUser(userId: RecordIdRef): Promise<SdkOrganizationMember[]> {
+  function listMembershipsForUser(userId: RecordIdRef) {
     const userRef = ensureRecordId(userId, TABLES.USER)
-    return (await this.findAll({ in: userRef }, { orderBy: 'createdAt', orderDir: 'ASC' })).map((record) =>
-      this.toPublic(record),
+    return findMembershipRecords({ in: userRef }, { orderBy: 'createdAt', orderDir: 'ASC' }).pipe(
+      Effect.mapError((cause) => toOrganizationMemberServiceError('listMembershipsForUser', cause)),
+      Effect.map((records) => records.map(toPublic)),
     )
   }
 
-  async getMembership(userId: RecordIdInput, organizationId: RecordIdInput): Promise<SdkOrganizationMember | null> {
+  function getMembership(userId: RecordIdInput, organizationId: RecordIdInput) {
     const userRef = ensureRecordId(userId, TABLES.USER)
     const organizationRef = ensureRecordId(organizationId, TABLES.ORGANIZATION)
-    const record = (await this.findAll({ in: userRef, out: organizationRef }, { limit: 1 })).at(0)
-    return record ? this.toPublic(record) : null
+    return findMembershipRecords({ in: userRef, out: organizationRef }, { limit: 1 }).pipe(
+      Effect.mapError((cause) => toOrganizationMemberServiceError('getMembership', cause)),
+      Effect.map((records) => records.at(0) ?? null),
+      Effect.map((record) => (record ? toPublic(record) : null)),
+    )
   }
 
-  async isMember(userId: RecordIdInput, organizationId: RecordIdInput): Promise<boolean> {
-    const userRef = ensureRecordId(userId, TABLES.USER)
-    const organizationRef = ensureRecordId(organizationId, TABLES.ORGANIZATION)
-    const existing = await this.findAll({ in: userRef, out: organizationRef }, { limit: 1 })
-    return existing.length > 0
+  function isMember(userId: RecordIdInput, organizationId: RecordIdInput) {
+    return getMembership(userId, organizationId).pipe(Effect.map((membership) => membership !== null))
   }
 
-  async removeMembership(params: { userId: RecordIdInput; organizationId: RecordIdInput }): Promise<void> {
+  function removeMembership(params: { userId: RecordIdInput; organizationId: RecordIdInput }) {
     const userRef = ensureRecordId(params.userId, TABLES.USER)
     const organizationRef = ensureRecordId(params.organizationId, TABLES.ORGANIZATION)
-    const existing = await this.findAll({ in: userRef, out: organizationRef }, { limit: 1 })
-    const record = existing.at(0)
-    if (!record) {
-      return
-    }
+    return Effect.gen(function* () {
+      const records = yield* findMembershipRecords({ in: userRef, out: organizationRef }, { limit: 1 }).pipe(
+        Effect.mapError((cause) => toOrganizationMemberServiceError('removeMembership.findExisting', cause)),
+      )
+      const record = records.at(0)
+      if (!record) {
+        return
+      }
+
+      yield* db
+        .deleteById(TABLES.ORGANIZATION_MEMBER, record.id)
+        .pipe(Effect.mapError((cause) => toOrganizationMemberServiceError('removeMembership.delete', cause)))
+    })
+  }
 
-    await this.delete(record.id)
+  return {
+    addMembership,
+    listMembershipsForOrganization,
+    listMembershipsForUser,
+    getMembership,
+    isMember,
+    removeMembership,
   }
 }
 
-export const organizationMemberService = new OrganizationMemberService()
+export class OrganizationMemberServiceTag extends Context.Service<
+  OrganizationMemberServiceTag,
+  ReturnType<typeof makeOrganizationMemberService>
+>()('@lota-sdk/core/OrganizationMemberService') {}
+
+export const OrganizationMemberServiceLive = Layer.effect(
+  OrganizationMemberServiceTag,
+  Effect.gen(function* () {
+    const db = yield* DatabaseServiceTag
+    return makeOrganizationMemberService(db)
+  }),
+)