Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

8.9 KB
Raw Blame
import { anyAbortSignal } from '@core/util/abort-signal';
import { fireAndForget } from '@core/util/fireAndForget';
import {
  invalidateSlackImport,
  parseSlackImportUpdate,
  type SlackImportClient,
  slackImportJobOptions,
  slackImportListOptions,
  slackImportMutationOptions,
} from '@queries/slack-import';
import type { createConnectionWebsocketEffect } from '@service-connection/websocket';
import type { ImportLimits as WireLimits } from '@service-storage/generated/schemas/importLimits';
import type { ImportProgress } from '@service-storage/generated/schemas/importProgress';
import type { uploadSlackImport } from '@service-storage/slack-import-upload';
import { type QueryClient, useMutation, useQuery } from '@tanstack/solid-query';
import { createEffect, createMemo, on, onCleanup } from 'solid-js';
import {
  type ImportCommands,
  type ImportJob,
  type ImportLimits,
  type ImportSource,
  type ImportSourceInputs,
  ImportUploadError,
} from '../context/contracts';

export type ImportSourceDependencies = {
  client: SlackImportClient;
  queryClient: QueryClient;
  /** Supply the existing generic gateway effect from the app-facing entry point. */
  gatewayEffect: typeof createConnectionWebsocketEffect;
  upload: typeof uploadSlackImport;
};

function toLimits(limits: WireLimits): ImportLimits {
  return {
    conversations: limits.conversations,
    jsonBytes: limits.jsonBytes,
    selectedBytes: limits.selectedBytes,
    zipEntries: limits.zipEntries,
    partBytes: limits.partBytes,
    partRecords: limits.partRecords,
    recordBytes: limits.recordBytes,
    registrationBatch: limits.registrationBatch,
  };
}

export function toImportJob(teamId: string, job: ImportProgress): ImportJob {
  return {
    teamId,
    source: { ...job.source },
    includeMessageHistory: job.includeMessageHistory,
    jobId: job.jobId,
    status: job.status,
    revision: job.revision,
    createdAt: job.createdAt,
    updatedAt: job.updatedAt,
    registrationClosed: job.registrationClosedAt != null,
    usersVerified: job.usersVerified,
    limits: toLimits(job.limits),
    conversations: job.conversations.map((conversation) => ({
      slackChannelId: conversation.slackChannelId,
      name: conversation.name,
      kind: conversation.kind,
      archived: conversation.archived,
      channelId:
        conversation.status === 'skipped'
          ? undefined
          : (conversation.channelId ?? undefined),
      status: conversation.status,
      counters: { ...conversation.counters },
      partCount: conversation.partCount ?? undefined,
      verifiedParts: conversation.verifiedParts,
      searchStatus: conversation.search.status,
      error: conversation.error ?? undefined,
      warnings: [...conversation.warnings],
    })),
  };
}

/** Construct under the consuming Solid owner; no production services are imported at runtime. */
export function createImportSource(
  dependencies: ImportSourceDependencies,
  inputs: ImportSourceInputs
): { source: ImportSource; commands: ImportCommands } {
  const { client, queryClient, gatewayEffect, upload } = dependencies;
  let disposed = false;
  const scope = createMemo(() => ({
    teamId: inputs.teamId(),
    enabled: inputs.enabled(),
  }));
  const enabled = () => !disposed && scope().enabled && Boolean(scope().teamId);
  const activeUploads = new Set<AbortController>();
  function abortUploads(): void {
    for (const controller of activeUploads) controller.abort();
    activeUploads.clear();
  }
  onCleanup(() => {
    disposed = true;
    abortUploads();
  });

  const pageQuery = useQuery(
    () =>
      slackImportListOptions(
        client,
        inputs.teamId() ?? '',
        enabled(),
        inputs.before?.()
      ),
    () => queryClient
  );
  const jobQuery = useQuery(
    () =>
      slackImportJobOptions(
        client,
        { teamId: inputs.teamId() ?? '', jobId: inputs.jobId() ?? '' },
        enabled()
      ),
    () => queryClient
  );

  createEffect(
    on(scope, () => {
      onCleanup(abortUploads);
      if (!enabled()) return;
      gatewayEffect((message) => {
        if (!enabled() || message.type !== 'slack_import_updated') return;
        const event = parseSlackImportUpdate(message.data);
        if (!event || event.teamId !== inputs.teamId()) return;
        fireAndForget(
          invalidateSlackImport(queryClient, event),
          'slack-import'
        );
      });
    })
  );

  const page = createMemo(() => {
    if (!enabled() || !(pageQuery.isSuccess || pageQuery.isRefetchError))
      return undefined;
    const data = pageQuery.data;
    if (!data?.value || !data.teamId || data.teamId !== inputs.teamId())
      return undefined;
    const page = data.value;
    const teamId = data.teamId;
    return {
      jobs: page.jobs.map((job) => toImportJob(teamId, job)),
      limits: toLimits(page.limits),
      sourceBinding: { ...page.sourceBinding },
      nextCursor: page.nextCursor ?? undefined,
    };
  });
  const job = createMemo(() => {
    if (
      !enabled() ||
      !inputs.jobId() ||
      !(jobQuery.isSuccess || jobQuery.isRefetchError)
    )
      return undefined;
    const data = jobQuery.data;
    if (
      !data?.value ||
      !data.teamId ||
      data.teamId !== inputs.teamId() ||
      data.value.jobId !== inputs.jobId()
    )
      return undefined;
    return toImportJob(data.teamId, data.value);
  });
  const source: ImportSource = {
    page: () => (enabled() ? page() : undefined),
    job: () => (enabled() ? job() : undefined),
    isLoading: () =>
      enabled() &&
      ((pageQuery.isPlaceholderData && pageQuery.isFetching) ||
        (jobQuery.isPlaceholderData && jobQuery.isFetching)),
    error: () =>
      enabled() ? (pageQuery.error ?? jobQuery.error ?? undefined) : undefined,
    async refresh() {
      if (!enabled()) return;
      await Promise.all([
        pageQuery.refetch({ throwOnError: true }),
        ...(inputs.jobId() ? [jobQuery.refetch({ throwOnError: true })] : []),
      ]);
    },
  };

  const options = slackImportMutationOptions(client, queryClient);
  const create = useMutation(
    () => options.create,
    () => queryClient
  );
  const register = useMutation(
    () => options.register,
    () => queryClient
  );
  const complete = useMutation(
    () => options.complete,
    () => queryClient
  );
  const finalize = useMutation(
    () => options.finalize,
    () => queryClient
  );
  const cancel = useMutation(
    () => options.cancel,
    () => queryClient
  );

  function requireScope(teamId: string): () => void {
    const started = scope();
    function check(): void {
      if (!enabled() || started !== scope() || teamId !== inputs.teamId()) {
        throw new Error('Slack import scope is no longer active');
      }
    }
    check();
    return check;
  }

  const commands: ImportCommands = {
    async create(teamId, body) {
      const check = requireScope(teamId);
      const job = await create.mutateAsync({ teamId, body });
      check();
      return toImportJob(teamId, job);
    },
    async register(identity, descriptors) {
      const check = requireScope(identity.teamId);
      const grants = await register.mutateAsync({
        ...identity,
        body: { descriptors },
      });
      check();
      return grants.map((grant) => ({
        descriptor: {
          ...grant.descriptor,
          upload: { ...grant.descriptor.upload },
        },
        expiresAt: grant.expiresAt,
        async put(blob, options) {
          check();
          const controller = new AbortController();
          activeUploads.add(controller);
          try {
            const signal = options?.signal
              ? anyAbortSignal([options.signal, controller.signal])
              : controller.signal;
            const result = await upload(grant, blob, { ...options, signal });
            check();
            if (result.isErr()) {
              const error = result.error;
              throw new ImportUploadError(
                error.code,
                error.code === 'HTTP_ERROR' ? error.status : undefined
              );
            }
            return result.value;
          } finally {
            activeUploads.delete(controller);
            // Releases the combined signal's listener on options.signal.
            controller.abort();
          }
        },
      }));
    },
    async complete(identity, uploads, seal) {
      const check = requireScope(identity.teamId);
      const job = await complete.mutateAsync({
        ...identity,
        body: { uploads, seal },
      });
      check();
      return toImportJob(identity.teamId, job);
    },
    async finalize(identity) {
      const check = requireScope(identity.teamId);
      const job = await finalize.mutateAsync(identity);
      check();
      return toImportJob(identity.teamId, job);
    },
    async cancel(identity) {
      const check = requireScope(identity.teamId);
      const job = await cancel.mutateAsync(identity);
      check();
      return toImportJob(identity.teamId, job);
    },
  };
  return { source, commands };
}