@elevasis/core 0.19.0 → 0.21.0

package/src/organization-model/schema.ts

@@ -70,8 +70,14 @@ function hasFeature(featuresById: Map<string, unknown>, featureId: string): bool
   return featuresById.has(featureId) || featuresById.has(LEGACY_FEATURE_ALIASES.get(featureId) ?? '')
 }
 
+function defaultFeaturePathFor(id: string): string {
+  return `/${id.replaceAll('.', '/')}`
+}
+
 export const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
   const featuresById = collectIds(model.features, ctx, ['features'], 'Feature')
+  const featureIdsByEffectivePath = new Map<string, string>()
+
   model.features.forEach((feature, featureIndex) => {
     const segments = feature.id.split('.')
     if (segments.length > 1) {
@@ -88,6 +94,21 @@ export const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((
     const hasChildren = model.features.some(
       (candidate) => candidate.id.startsWith(`${feature.id}.`) && candidate.id !== feature.id
     )
+    const contributesRoutePath = feature.path !== undefined || !hasChildren
+    if (contributesRoutePath) {
+      const effectivePath = feature.path ?? defaultFeaturePathFor(feature.id)
+      const existingFeatureId = featureIdsByEffectivePath.get(effectivePath)
+      if (existingFeatureId !== undefined) {
+        addIssue(
+          ctx,
+          ['features', featureIndex, feature.path === undefined ? 'id' : 'path'],
+          `Feature "${feature.id}" effective path "${effectivePath}" duplicates feature "${existingFeatureId}"`
+        )
+      } else {
+        featureIdsByEffectivePath.set(effectivePath, feature.id)
+      }
+    }
+
     if (hasChildren && feature.enabled) {
       const hasEnabledDescendant = model.features.some(
         (candidate) => candidate.id.startsWith(`${feature.id}.`) && candidate.enabled
@@ -102,6 +123,48 @@ export const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((
     }
   })
 
+  const surfacesById = collectIds(model.navigation.surfaces, ctx, ['navigation', 'surfaces'], 'Navigation surface')
+
+  if (model.navigation.defaultSurfaceId !== undefined && !surfacesById.has(model.navigation.defaultSurfaceId)) {
+    addIssue(
+      ctx,
+      ['navigation', 'defaultSurfaceId'],
+      `Navigation defaultSurfaceId references unknown surface "${model.navigation.defaultSurfaceId}"`
+    )
+  }
+
+  model.navigation.groups.forEach((group, groupIndex) => {
+    group.surfaceIds.forEach((surfaceId, surfaceIndex) => {
+      if (!surfacesById.has(surfaceId)) {
+        addIssue(
+          ctx,
+          ['navigation', 'groups', groupIndex, 'surfaceIds', surfaceIndex],
+          `Navigation group "${group.id}" references unknown surface "${surfaceId}"`
+        )
+      }
+    })
+  })
+
+  model.navigation.surfaces.forEach((surface, surfaceIndex) => {
+    if (surface.featureId !== undefined && !hasFeature(featuresById, surface.featureId)) {
+      addIssue(
+        ctx,
+        ['navigation', 'surfaces', surfaceIndex, 'featureId'],
+        `Navigation surface "${surface.id}" references unknown feature "${surface.featureId}"`
+      )
+    }
+
+    surface.featureIds.forEach((featureId, featureIndex) => {
+      if (!hasFeature(featuresById, featureId)) {
+        addIssue(
+          ctx,
+          ['navigation', 'surfaces', surfaceIndex, 'featureIds', featureIndex],
+          `Navigation surface "${surface.id}" references unknown feature "${featureId}"`
+        )
+      }
+    })
+  })
+
   // Offerings -> CustomerSegment cross-ref: targetSegmentIds must resolve
   const segmentsById = new Map(model.customers.segments.map((seg) => [seg.id, seg]))
   model.offerings.products.forEach((product, productIndex) => {

package/src/organization-model/surface-projection.ts

@@ -0,0 +1,218 @@
+import type { OrganizationModel, OrganizationModelFeature, OrganizationModelSurface } from './types'
+
+export type OrganizationSurfaceProjectionIssueCode =
+  | 'duplicate-surface-id'
+  | 'duplicate-surface-path'
+  | 'unknown-default-surface'
+  | 'unknown-group-surface'
+  | 'unknown-surface-feature'
+  | 'unknown-surface-feature-reference'
+
+export interface OrganizationSurfaceProjection {
+  id: string
+  label: string
+  path: string
+  surfaceType: OrganizationModelSurface['surfaceType']
+  featureId?: string
+  featureIds: string[]
+  entityIds: string[]
+  resourceIds: string[]
+  capabilityIds: string[]
+  enabled: boolean
+  devOnly?: boolean
+  requiresAdmin?: boolean
+}
+
+export interface OrganizationSurfaceProjectionIssue {
+  code: OrganizationSurfaceProjectionIssueCode
+  message: string
+  path: Array<string | number>
+  surfaceId?: string
+  featureId?: string
+  groupId?: string
+  value?: string
+}
+
+const LEGACY_FEATURE_ALIASES = new Map<string, string>([
+  ['crm', 'sales.crm'],
+  ['lead-gen', 'sales.lead-gen'],
+  ['submitted-requests', 'monitoring.submitted-requests']
+])
+
+function normalizePath(path: string): string {
+  return path.length > 1 ? path.replace(/\/+$/, '') : path
+}
+
+function collectFeaturesById(model: OrganizationModel): Map<string, OrganizationModelFeature> {
+  return new Map(model.features.map((feature) => [feature.id, feature]))
+}
+
+function resolveFeatureId(featuresById: Map<string, OrganizationModelFeature>, featureId: string): string | undefined {
+  if (featuresById.has(featureId)) {
+    return featureId
+  }
+
+  const aliasTarget = LEGACY_FEATURE_ALIASES.get(featureId)
+  return aliasTarget !== undefined && featuresById.has(aliasTarget) ? aliasTarget : undefined
+}
+
+function getFeatureWithAncestors(
+  featuresById: Map<string, OrganizationModelFeature>,
+  featureId: string
+): OrganizationModelFeature[] {
+  const features: OrganizationModelFeature[] = []
+  const segments = featureId.split('.')
+
+  for (let index = 1; index <= segments.length; index += 1) {
+    const candidate = featuresById.get(segments.slice(0, index).join('.'))
+    if (candidate) {
+      features.push(candidate)
+    }
+  }
+
+  return features
+}
+
+function hasInheritedFlag(
+  featuresById: Map<string, OrganizationModelFeature>,
+  featureIds: string[],
+  flag: 'devOnly' | 'requiresAdmin'
+): boolean {
+  return featureIds.some((featureId) =>
+    getFeatureWithAncestors(featuresById, featureId).some((feature) => feature[flag] === true)
+  )
+}
+
+function isFeatureEnabled(featuresById: Map<string, OrganizationModelFeature>, featureId: string): boolean {
+  const featureLineage = getFeatureWithAncestors(featuresById, featureId)
+  return featureLineage.length > 0 && featureLineage.every((feature) => feature.enabled)
+}
+
+function unique(values: string[]): string[] {
+  return [...new Set(values)]
+}
+
+export function projectOrganizationSurfaces(model: OrganizationModel): OrganizationSurfaceProjection[] {
+  const featuresById = collectFeaturesById(model)
+
+  return model.navigation.surfaces.map((surface) => {
+    const featureId = surface.featureId ? resolveFeatureId(featuresById, surface.featureId) : undefined
+    const featureIds = unique(
+      [featureId, ...surface.featureIds.map((candidate) => resolveFeatureId(featuresById, candidate))].filter(
+        (candidate): candidate is string => candidate !== undefined
+      )
+    )
+    const enabled = surface.enabled && featureIds.every((candidate) => isFeatureEnabled(featuresById, candidate))
+    const devOnly = surface.devOnly === true || hasInheritedFlag(featuresById, featureIds, 'devOnly')
+    const requiresAdmin = hasInheritedFlag(featuresById, featureId ? [featureId] : featureIds, 'requiresAdmin')
+
+    return {
+      id: surface.id,
+      label: surface.label,
+      path: surface.path,
+      surfaceType: surface.surfaceType,
+      featureId,
+      featureIds,
+      entityIds: [...surface.entityIds],
+      resourceIds: [...surface.resourceIds],
+      capabilityIds: [...surface.capabilityIds],
+      enabled,
+      ...(devOnly ? { devOnly } : {}),
+      ...(requiresAdmin ? { requiresAdmin } : {})
+    }
+  })
+}
+
+export function validateOrganizationSurfaceProjection(model: OrganizationModel): OrganizationSurfaceProjectionIssue[] {
+  const issues: OrganizationSurfaceProjectionIssue[] = []
+  const featuresById = collectFeaturesById(model)
+  const surfaceIds = new Set<string>()
+  const surfacePaths = new Map<string, string>()
+
+  function addIssue(issue: OrganizationSurfaceProjectionIssue): void {
+    issues.push(issue)
+  }
+
+  model.navigation.surfaces.forEach((surface, surfaceIndex) => {
+    if (surfaceIds.has(surface.id)) {
+      addIssue({
+        code: 'duplicate-surface-id',
+        message: `Surface id "${surface.id}" must be unique`,
+        path: ['navigation', 'surfaces', surfaceIndex, 'id'],
+        surfaceId: surface.id,
+        value: surface.id
+      })
+    } else {
+      surfaceIds.add(surface.id)
+    }
+
+    const normalizedPath = normalizePath(surface.path)
+    const existingSurfaceId = surfacePaths.get(normalizedPath)
+    if (existingSurfaceId !== undefined) {
+      addIssue({
+        code: 'duplicate-surface-path',
+        message: `Surface path "${surface.path}" is already used by surface "${existingSurfaceId}"`,
+        path: ['navigation', 'surfaces', surfaceIndex, 'path'],
+        surfaceId: surface.id,
+        value: surface.path
+      })
+    } else {
+      surfacePaths.set(normalizedPath, surface.id)
+    }
+
+    if (surface.featureId !== undefined && resolveFeatureId(featuresById, surface.featureId) === undefined) {
+      addIssue({
+        code: 'unknown-surface-feature',
+        message: `Surface "${surface.id}" references unknown feature "${surface.featureId}"`,
+        path: ['navigation', 'surfaces', surfaceIndex, 'featureId'],
+        surfaceId: surface.id,
+        featureId: surface.featureId,
+        value: surface.featureId
+      })
+    }
+
+    surface.featureIds.forEach((featureId, featureIndex) => {
+      if (resolveFeatureId(featuresById, featureId) !== undefined) {
+        return
+      }
+
+      addIssue({
+        code: 'unknown-surface-feature-reference',
+        message: `Surface "${surface.id}" references unknown feature "${featureId}"`,
+        path: ['navigation', 'surfaces', surfaceIndex, 'featureIds', featureIndex],
+        surfaceId: surface.id,
+        featureId,
+        value: featureId
+      })
+    })
+  })
+
+  if (model.navigation.defaultSurfaceId !== undefined && !surfaceIds.has(model.navigation.defaultSurfaceId)) {
+    addIssue({
+      code: 'unknown-default-surface',
+      message: `Default surface "${model.navigation.defaultSurfaceId}" is not declared in navigation.surfaces`,
+      path: ['navigation', 'defaultSurfaceId'],
+      surfaceId: model.navigation.defaultSurfaceId,
+      value: model.navigation.defaultSurfaceId
+    })
+  }
+
+  model.navigation.groups.forEach((group, groupIndex) => {
+    group.surfaceIds.forEach((surfaceId, surfaceIndex) => {
+      if (surfaceIds.has(surfaceId)) {
+        return
+      }
+
+      addIssue({
+        code: 'unknown-group-surface',
+        message: `Navigation group "${group.id}" references unknown surface "${surfaceId}"`,
+        path: ['navigation', 'groups', groupIndex, 'surfaceIds', surfaceIndex],
+        surfaceId,
+        groupId: group.id,
+        value: surfaceId
+      })
+    })
+  })
+
+  return issues
+}

package/src/platform/constants/versions.ts

@@ -1,3 +1,3 @@
 export const VERSION = {
-  CURRENT: '1.8.1'
+  CURRENT: '1.8.7'
 }

package/src/reference/_generated/contracts.md

@@ -1123,7 +1123,7 @@ export const DEFAULT_CRM_PRIORITY_RULE_CONFIG: CrmPriorityRuleConfig = {
 ### `DealStageSchema`
 
 ```typescript
-export const DealStageSchema = z.enum(['interested', 'proposal', 'closing', 'closed_won', 'closed_lost', 'nurturing'])
+export const DealStageSchema = CrmStageKeySchema
 ```
 
 ### `AcqDealTaskKindSchema`
@@ -1215,7 +1215,7 @@ export const TransitionItemRequestSchema = z
   .object({
     pipelineKey: z.string().min(1),
     stageKey: z.string().min(1),
-    stateKey: z.string().nullable().optional(),
+    stateKey: z.string().min(1).nullable().optional(),
     reason: z.string().optional(),
     expectedUpdatedAt: z.string().datetime().optional()
   })
@@ -1409,6 +1409,11 @@ export const DealTaskListResponseSchema = z.array(DealTaskResponseSchema)
 
 ```typescript
 export const DealSchemas = {
+  // Primitives
+  CrmStageKey: CrmStageKeySchema,
+  CrmStateKey: CrmStateKeySchema,
+  DealStage: DealStageSchema,
+
   // Params
   DealIdParams: DealIdParamsSchema,
   DealTaskIdParams: DealTaskIdParamsSchema,
@@ -1421,7 +1426,7 @@ export const DealSchemas = {
   // Request bodies
   CreateDealNoteRequest: CreateDealNoteRequestSchema,
   CreateDealTaskRequest: CreateDealTaskRequestSchema,
-  TransitionItemRequest: TransitionItemRequestSchema,
+  TransitionItemRequest: CrmTransitionItemRequestSchema,
   TransitionDealStateRequest: TransitionDealStateRequestSchema,
   ExecuteActionParams: ExecuteActionParamsSchema,
   ExecuteActionRequest: ExecuteActionRequestSchema,
@@ -2544,15 +2549,20 @@ export const AcqSubstrateSchemas = {
 
   // List members
   ListMembersQuery: ListMembersQuerySchema,
+  ListRecordsQuery: ListRecordsQuerySchema,
   MemberIdParams: MemberIdParamsSchema,
   AcqListMemberResponse: AcqListMemberResponseSchema,
   AcqListMembersResponse: AcqListMembersResponseSchema,
+  AcqListCompanyRecordRow: AcqListCompanyRecordRowSchema,
+  AcqListContactRecordRow: AcqListContactRecordRowSchema,
+  ListRecordRow: ListRecordRowSchema,
+  ListRecordsResponse: ListRecordsResponseSchema,
 
   // List companies
   ListCompanyIdParams: ListCompanyIdParamsSchema,
   AcqListCompanyResponse: AcqListCompanyResponseSchema,
 
-  // Transition (shared with deals — TransitionItemRequestSchema)
+  // Transition (generic stateful substrate)
   TransitionItemRequest: TransitionItemRequestSchema
 }
 ```
@@ -2620,6 +2630,8 @@ export interface StatefulStageDefinition {
   /** Matches stage_key values written by workflow steps. */
   stageKey: string
   label: string
+  /** UI color token. Consumers may map this to their design system. */
+  color?: string
   states: StatefulStateDefinition[]
 }
 ```
@@ -2702,7 +2714,7 @@ export const ACQ_LIST_COMPANIES_LEAD_GEN_PIPELINE: StatefulPipelineDefinition =
     {
       stageKey: 'outreach',
       label: 'Outreach',
-      states: [PENDING_STATE]
+      states: [PENDING_STATE, { stateKey: 'uploaded', label: 'Uploaded' }]
     },
     {
       stageKey: 'prospecting',

package/src/server.ts

@@ -60,6 +60,7 @@ export { GmailAdapter } from './execution/engine/tools/integration/server/adapte
 export { AttioAdapter } from './execution/engine/tools/integration/server/adapters/attio'
 export { GoogleSheetsAdapter } from './execution/engine/tools/integration/server/adapters/google-sheets'
 export { ApifyAdapter } from './execution/engine/tools/integration/server/adapters/apify'
+export { ApolloAdapter } from './execution/engine/tools/integration/server/adapters/apollo'
 export { InstantlyAdapter } from './execution/engine/tools/integration/server/adapters/instantly'
 export { ResendAdapter } from './execution/engine/tools/integration/server/adapters/resend'
 export { AnymailfinderAdapter } from './execution/engine/tools/integration/server/adapters/anymailfinder'
@@ -68,6 +69,7 @@ export { MillionVerifierAdapter } from './execution/engine/tools/integration/ser
 export { StripeAdapter } from './execution/engine/tools/integration/server/adapters/stripe'
 export { SignatureApiAdapter } from './execution/engine/tools/integration/server/adapters/signature-api'
 export { DropboxAdapter } from './execution/engine/tools/integration/server/adapters/dropbox'
+export { ClickUpAdapter } from './execution/engine/tools/integration/server/adapters/clickup'
 export {
   GoogleCalendarAdapter,
   type CalendarEvent,