Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
import { useCreateContext } from '@app/features/command/context/create-context';
import { useQuickAccessCrmCompaniesQuery } from '@app/features/crm/crm-search';
import { composeEmail } from '@app/features/email-view/compose-email';
import { withEntityNotifications } from '@app/features/soup/entity-notifications';
import { useFeatureFlag } from '@app/lib/analytics/posthog';
import { useGlobalNotificationSource } from '@components/app/GlobalAppState';
import { useSplitLayout } from '@components/app/split-layout/layout';
import { useSplitPanel } from '@components/app/split-layout/layoutUtils';
import { toast } from '@core/component/Toast/Toast';
import {
enableCrmActivity,
enableCrmLists,
enableCrmPipelines,
} from '@core/constant/featureFlags';
import { useUserId } from '@core/context/user';
import { useProfilePictureUrl } from '@core/signal/profilePicture';
import { emailToMacroId, getInitialsFromName } from '@core/user';
import { idToEmail } from '@core/user/util';
import { fireAndForget } from '@core/util/fireAndForget';
import type { EntityData } from '@entity';
import { useTagSets, useTagSetsReady } from '@property/tags/tag-sets-context';
import { queryReadyGate } from '@queries/gate';
import { useListPropertiesQuery } from '@queries/properties/definitions';
import { useBulkSaveEntityPropertiesMutation } from '@queries/properties/entity';
import {
type SoupAstItemsQuery,
useSoupAstItemsQuery,
} from '@queries/soup/items';
import { getSoupEntityById } from '@queries/soup/normalized-cache';
import {
invalidateUserTeams,
useCurrentTeamQuery,
useIsTeamAdmin,
} from '@queries/team/teams';
import { patchTeamCrmSettings } from '@service-auth/crm';
import { storageServiceClient } from '@service-storage/client';
import { getGraphqlSoupClient } from '@service-storage/graphql-soup';
import { useNavigate } from '@solidjs/router';
import { useQueryClient } from '@tanstack/solid-query';
import { createMemo, lazy } from 'solid-js';
import { createTagFacetContext } from '../soup';
import { createCrmActivityFilters } from './activity-filters-adapter';
import { createCrmActivityState } from './activity-state-adapter';
import type { CrmContext } from './context/crm-context';
import type { CrmQuery, ItemListSource } from './context/crm-sources';
import {
openCreateCompanyModal,
openCreateContactModal,
} from './creation-adapter';
import { createAppCrmDisplayOptions } from './display-adapter';
import { downloadCrmCsv } from './download-adapter';
import {
copyCrmPipelineLink,
copyCrmRecordLink,
copyCrmViewLink,
createAppCrmNavigation,
} from './navigation-adapter';
import { PipelineDatabaseEditor, PipelineShare } from './pipeline-adapter';
import { createCrmPipelineEntries } from './pipeline-entries-adapter';
import { createCrmPermissions } from './primitives/team-config';
import { useCrmActivityQuery } from './queries/activity';
import { crmActivityItemMatches } from './queries/activity-options';
import { useBlockedDomains } from './queries/blocked-domains';
import {
createCompanyImporter,
useCompanyQuery,
useCreateCompanyMutation,
useCreateContactMutation,
useSetCompanyHiddenMutation,
useSetCompanyNameMutation,
useSetEmailSyncMutation,
} from './queries/companies';
import { useCompanyEmailsQuery } from './queries/company-emails';
import { useContactEmailsQuery } from './queries/contact-emails';
import {
useContactQuery,
useSetContactHiddenMutation,
useSetContactNameMutation,
} from './queries/contacts';
import { fetchCrmExportCompanies } from './queries/export';
import { useCrmLists } from './queries/lists';
import { createPipelineTransfer } from './queries/pipeline-transfer';
import { createPipelinesSource } from './queries/pipelines';
import {
recordListFailure,
useRecordCallsQuery,
useRecordFilesQuery,
useRecordReferencesQuery,
} from './queries/record-items';
import { usePersonalCrmViews, useTeamCrmViews } from './queries/saved-views';
import { usePatchTeamCrmSettingsMutation } from './queries/settings-commands';
import {
useReplaceCrmStagesMutation,
useResetCrmStagesMutation,
} from './queries/stages';
import { useTeamCrmConfig } from './queries/team-config';
import { useQuickAccessCrmContactsQuery } from './record-adapter';
import { createAppDealStages } from './stage-adapter';
import { crmTaskComposerContext } from './task-composer';
// Loaded on demand: the Tasks list imports soup, which imports CRM entry points.
const CrmRecordTasks = lazy(async () => ({
default: (await import('./record-tasks-adapter')).CrmRecordTasks,
}));
const CrmActivityTasks = lazy(async () => ({
default: (await import('./activity-tasks-adapter')).CrmActivityTasks,
}));
/**
* Soup rows carry raw notification arrays; `ListEntity` reads them through
* an accessor bound to the app's notification source, as other lists do.
*/
function withRowNotifications(
source: SoupAstItemsQuery,
matches?: (entity: EntityData) => boolean
): ItemListSource {
const notificationSource = useGlobalNotificationSource();
// Reading `data` before the first page resolves would suspend the tab.
const data = createMemo(() =>
queryReadyGate(source)
? {
entities: source.data.entities
.filter((entity) => !matches || matches(entity))
.map((entity) =>
withEntityNotifications(entity, notificationSource)
),
}
: undefined
);
return {
get isPending() {
return source.isPending;
},
get isEnabled() {
return source.isEnabled;
},
get isLoading() {
return source.isLoading;
},
get data() {
return data();
},
get hasNextPage() {
return source.hasNextPage;
},
get isFetchingNextPage() {
return source.isFetchingNextPage;
},
get isError() {
return recordListFailure(source).isError;
},
get isFetchNextPageError() {
return recordListFailure(source).isFetchNextPageError;
},
fetchNextPage: () => source.fetchNextPage(),
refetch: () => source.refetch(),
};
}
/**
* A query contract whose `data` reads as `undefined` until the query is
* ready, so views can read it eagerly (e.g. in a memo) without suspending.
*/
function withReadyGate<T>(query: CrmQuery<T>): CrmQuery<T> {
return {
get data() {
return queryReadyGate(query) ? query.data : undefined;
},
get isPending() {
return query.isPending;
},
get isSuccess() {
return query.isSuccess;
},
get isLoading() {
return query.isLoading;
},
get isError() {
return query.isError;
},
refetch: () => query.refetch(),
};
}
/** Only this app-facing adapter constructs production capabilities. */
export function createAppCrmContext(): CrmContext {
const deps = {
client: useQueryClient(),
storage: storageServiceClient,
feedback: toast,
};
const userId = useUserId();
const layout = useSplitLayout();
const panel = useSplitPanel();
const createContext = useCreateContext();
const activityFlag = useFeatureFlag(enableCrmActivity);
const navigate = useNavigate();
const openCreateItem = async (kind: 'notes' | 'calls') => {
if (kind === 'calls') {
navigate('/meet/new');
return;
}
const { runCreateAction } = await import('@app/features/command/Launcher');
runCreateAction('md', { source: 'crm' });
};
const createSettings = () => useTeamCrmConfig(deps);
return {
registerTaskComposerRecord(source) {
if (!panel) return () => {};
return createContext.register(panel.handle.id, () => ({
task: activityFlag().enabled ? crmTaskComposerContext(source()) : null,
}));
},
createPipelines: (teamId) => createPipelinesSource(deps, teamId),
PipelineEditor: PipelineDatabaseEditor,
PipelineEntries: createCrmPipelineEntries({
graphql: getGraphqlSoupClient,
storage: deps.storage,
}),
PipelineSharing: PipelineShare,
createPipelineTransfer: (pipeline) =>
createPipelineTransfer(deps, pipeline),
feedback: toast,
downloadCsv: downloadCrmCsv,
createContactPhoto: (email) =>
useProfilePictureUrl(emailToMacroId(email))[0],
contactInitials: getInitialsFromName,
userEmail: idToEmail,
createNavigation: createAppCrmNavigation,
copyRecordLink: copyCrmRecordLink,
copyViewLink: copyCrmViewLink,
copyPipelineLink: copyCrmPipelineLink,
listsEnabled() {
const flag = useFeatureFlag(enableCrmLists);
return () => flag().enabled;
},
pipelinesEnabled() {
const flag = useFeatureFlag(enableCrmPipelines);
return () => flag().enabled;
},
createCompanyEmails: (...args) =>
withRowNotifications(
useCompanyEmailsQuery(useSoupAstItemsQuery, ...args)
),
createContactEmails: (...args) =>
withRowNotifications(
useContactEmailsQuery(useSoupAstItemsQuery, ...args)
),
openCreateItem: (kind) => fireAndForget(openCreateItem(kind), 'crm'),
openEmailComposer: (recipient) =>
composeEmail(
layout.openWithSplit,
undefined,
recipient ? [recipient] : undefined
),
createActivity: (tab, options) => {
const tags = useTagSets();
const tagsReady = useTagSetsReady();
const facetContext = createMemo(() => createTagFacetContext(tags()));
return withRowNotifications(
useCrmActivityQuery(
useSoupAstItemsQuery,
tab,
userId,
options,
facetContext,
tagsReady
),
options
? (entity) =>
crmActivityItemMatches(entity, tab(), options(), facetContext())
: undefined
);
},
createActivityState: createCrmActivityState,
createActivityFilters: createCrmActivityFilters,
ActivityTasks: CrmActivityTasks,
openTaskComposer: (options) =>
layout.popoverSplit({
type: 'component',
id: 'task-compose',
params: {
initialDueDate: options?.dueDate,
composerContext:
options?.composerContext ??
(panel
? createContext.snapshot('task', panel.handle.id)
: undefined),
},
}),
createRecordFiles: (scope) =>
withRowNotifications(useRecordFilesQuery(useSoupAstItemsQuery, scope)),
createRecordCalls: (scope) =>
withRowNotifications(useRecordCallsQuery(useSoupAstItemsQuery, scope)),
createRecordReferences: (scope) =>
withRowNotifications(
useRecordReferencesQuery(useSoupAstItemsQuery, scope)
),
RecordTasks: CrmRecordTasks,
createPropertyCommands: useBulkSaveEntityPropertiesMutation,
createSettingsCommands: () =>
usePatchTeamCrmSettingsMutation({
...deps,
patch: patchTeamCrmSettings,
invalidateTeams: invalidateUserTeams,
}),
createReplaceStages: () => useReplaceCrmStagesMutation(deps),
createResetStages: () => useResetCrmStagesMutation(deps),
exportCompanies: (...args) =>
fetchCrmExportCompanies(deps.storage, ...args),
createCompanySuggestions: useQuickAccessCrmCompaniesQuery,
createContactSuggestions: useQuickAccessCrmContactsQuery,
hydrateCompany(company) {
if (company.properties) return company;
const cached = getSoupEntityById(company.id);
return cached?.tag === 'crmCompany'
? { ...company, properties: cached.data.properties }
: company;
},
createExportDefinitions(enabled) {
const query = useListPropertiesQuery(
() => ({
scope: 'all',
includeOptions: true,
forEntityType: 'COMPANY',
}),
enabled
);
return {
get isPending() {
return query.isPending;
},
get isSuccess() {
return query.isSuccess;
},
get isError() {
return query.isError;
},
get data() {
return (query.data ?? []).map((entry) =>
'definition' in entry
? entry
: { definition: entry, property_options: [] }
);
},
};
},
createDisplayOptions: createAppCrmDisplayOptions,
openCreateCompany: openCreateCompanyModal,
openCreateContact: openCreateContactModal,
userId,
isTeamAdmin: useIsTeamAdmin,
createCompanySource: (...args) => useCompanyQuery(deps, ...args),
createContactSource: (...args) =>
withReadyGate(useContactQuery(deps, ...args)),
createTeamSource: useCurrentTeamQuery,
createTeamConfigSource: createSettings,
createBlockedDomains: () => useBlockedDomains(deps),
createCapabilities: () =>
createCrmPermissions(userId, useCurrentTeamQuery(), createSettings()),
createDealStages: createAppDealStages,
createPersonalViews: () => usePersonalCrmViews(deps),
createTeamViews: () => useTeamCrmViews(deps, userId, createSettings()),
createLists: (teamId) => useCrmLists(deps, teamId),
createCompany: (...args) => useCreateCompanyMutation(deps, ...args),
createCompanyImporter: () => createCompanyImporter(deps),
createContact: (...args) => useCreateContactMutation(deps, ...args),
renameCompany: (...args) => useSetCompanyNameMutation(deps, ...args),
renameContact: (...args) => useSetContactNameMutation(deps, ...args),
hideCompany: (...args) => useSetCompanyHiddenMutation(deps, ...args),
hideContact: (...args) => useSetContactHiddenMutation(deps, ...args),
setEmailSync: (...args) => useSetEmailSyncMutation(deps, ...args),
};
}