memind/health-data-runtime.mjs

import { createInMemoryHealthObservationStore } from './health-observation-store.mjs';
import { createInMemoryHealthDocumentStore } from './health-document-store.mjs';
import { createInMemoryHealthObservationDraftStore } from './health-observation-draft-store.mjs';
import { createInMemoryHealthBaselineStore } from './health-baseline-store.mjs';
import { createInMemoryHealthEventStore } from './health-event-store.mjs';
import { createPageDataHealthObservationStore } from './health-page-data-observation-store.mjs';
import { createPageDataHealthDocumentStore } from './health-page-data-document-store.mjs';
import { createPageDataHealthObservationDraftStore } from './health-page-data-draft-store.mjs';
import { createPageDataHealthBaselineStore } from './health-page-data-baseline-store.mjs';
import { createPageDataHealthEventStore } from './health-page-data-event-store.mjs';
import { createHealthObservationService } from './health-observation-service.mjs';
import { createHealthObservationDraftService } from './health-observation-draft-service.mjs';
import { createHealthShareService } from './health-share-service.mjs';
import { computeHealthBaselines } from './health-baseline-engine.mjs';
import { evaluateHealthEvents } from './health-event-engine.mjs';

function shouldUsePageDataHealthStore(env = process.env) {
  if (env.MEMIND_HEALTH_PAGE_DATA === '0') return false;
  if (env.MEMIND_HEALTH_PAGE_DATA === '1') return true;
  if (env.NODE_TEST_CONTEXT) return false;
  const backend = String(env.MINDSPACE_USERDATA_BACKEND ?? '').trim().toLowerCase();
  return backend === 'postgres';
}

export function createHealthDataRuntime(deps = {}) {
  const env = deps.env ?? process.env;
  const usePageData = deps.usePageData ?? shouldUsePageDataHealthStore(env);
  const resolveWorkspaceRoot =
    deps.resolveWorkspaceRoot
    ?? (async (userId) => {
      const auth = deps.getUserAuth?.();
      if (!auth?.resolveWorkingDir) return null;
      return auth.resolveWorkingDir(userId);
    });

  let observationStore = createInMemoryHealthObservationStore();
  let documentStore = createInMemoryHealthDocumentStore();
  let draftStore = createInMemoryHealthObservationDraftStore();
  let baselineStore = createInMemoryHealthBaselineStore();
  let eventStore = createInMemoryHealthEventStore();

  if (usePageData) {
    observationStore = createPageDataHealthObservationStore({ resolveWorkspaceRoot, logger: deps.logger });
    documentStore = createPageDataHealthDocumentStore({ resolveWorkspaceRoot, logger: deps.logger });
    draftStore = createPageDataHealthObservationDraftStore({ resolveWorkspaceRoot, logger: deps.logger });
    baselineStore = createPageDataHealthBaselineStore({ resolveWorkspaceRoot, logger: deps.logger });
    eventStore = createPageDataHealthEventStore({ resolveWorkspaceRoot, logger: deps.logger });
  }

  let observationService = createHealthObservationService({ store: observationStore });
  let draftService = createHealthObservationDraftService({
    draftStore,
    observationService,
  });
  let shareService = createHealthShareService({
    observationService,
    baselineEngine: { computeHealthBaselines },
    eventEngine: { evaluateHealthEvents },
  });

  function rebuildServices() {
    observationService = createHealthObservationService({ store: observationStore });
    draftService = createHealthObservationDraftService({
      draftStore,
      observationService,
    });
    shareService = createHealthShareService({
      observationService,
      baselineEngine: { computeHealthBaselines },
      eventEngine: { evaluateHealthEvents },
    });
  }

  return {
    get observationStore() {
      return observationStore;
    },
    get documentStore() {
      return documentStore;
    },
    get draftStore() {
      return draftStore;
    },
    get baselineStore() {
      return baselineStore;
    },
    get eventStore() {
      return eventStore;
    },
    get observationService() {
      return observationService;
    },
    get draftService() {
      return draftService;
    },
    get shareService() {
      return shareService;
    },
    get storageBackend() {
      return usePageData ? 'page_data' : 'memory';
    },
    upgradeToPageData(nextDeps = {}) {
      if (!shouldUsePageDataHealthStore(nextDeps.env ?? env)) return false;
      const resolver = nextDeps.resolveWorkspaceRoot ?? resolveWorkspaceRoot;
      observationStore = createPageDataHealthObservationStore({
        resolveWorkspaceRoot: resolver,
        logger: nextDeps.logger ?? deps.logger,
      });
      documentStore = createPageDataHealthDocumentStore({
        resolveWorkspaceRoot: resolver,
        logger: nextDeps.logger ?? deps.logger,
      });
      draftStore = createPageDataHealthObservationDraftStore({
        resolveWorkspaceRoot: resolver,
        logger: nextDeps.logger ?? deps.logger,
      });
      baselineStore = createPageDataHealthBaselineStore({
        resolveWorkspaceRoot: resolver,
        logger: nextDeps.logger ?? deps.logger,
      });
      eventStore = createPageDataHealthEventStore({
        resolveWorkspaceRoot: resolver,
        logger: nextDeps.logger ?? deps.logger,
      });
      rebuildServices();
      return true;
    },
    rebuildServices,
  };
}