@elevasis/core 0.19.0 → 0.21.0

package/src/integrations/credentials/schemas.ts

@@ -1,164 +1,200 @@
-import { z } from 'zod'
-
-/**
- * Credential field definition
- */
-export interface CredentialField {
-  key: string
-  label: string
-  type: 'password' | 'text'
-  required: boolean
-  placeholder?: string
-  description?: string
-}
-
-/**
- * Credential schema definition
- */
-export interface CredentialSchema {
-  type: string
-  label: string
-  description: string
-  fields?: CredentialField[]
-  docsUrl?: string
-  nameSuggestions: string[]
-  oauthProvider?: string // For OAuth types
-}
-
-/**
- * Zod schemas for runtime validation
- */
-const CredentialFieldSchema = z.object({
-  key: z.string(),
-  label: z.string(),
-  type: z.enum(['password', 'text']),
-  required: z.boolean(),
-  placeholder: z.string().optional(),
-  description: z.string().optional()
-})
-
-const CredentialSchemaZod = z.object({
-  type: z.string(),
-  label: z.string(),
-  description: z.string(),
-  fields: z.array(CredentialFieldSchema).optional(),
-  docsUrl: z.string().url().optional(),
-  nameSuggestions: z.array(z.string()),
-  oauthProvider: z.string().optional()
-})
-
-/**
- * Credential Schema Registry
- *
- * Add new integration = add schema object here (no modal changes needed)
- *
- * Schema types:
- * - oauth: OAuth-based authentication (handled via OAuth flow)
- * - single_field: Single API key field (generic)
- */
-export const CREDENTIAL_SCHEMAS: Record<string, CredentialSchema> = {
-  'google-sheets': {
-    type: 'oauth',
-    label: 'Google Sheets',
-    description: 'Google Sheets OAuth integration',
-    oauthProvider: 'google-sheets',
-    nameSuggestions: ['google-sheets-prod', 'google-sheets-dev', 'sheets-workspace']
-  },
-
-  dropbox: {
-    type: 'oauth',
-    label: 'Dropbox',
-    description: 'Dropbox OAuth integration',
-    oauthProvider: 'dropbox',
-    nameSuggestions: ['dropbox-prod', 'dropbox-dev', 'elevasis-dropbox']
-  },
-
-  oauth: {
-    type: 'oauth',
-    label: 'OAuth',
-    description: 'Generic OAuth credential',
-    nameSuggestions: []
-  },
-
-  'api-key': {
-    type: 'single_field',
-    label: 'API Key',
-    description: 'Single-field API key credential',
-    fields: [
-      {
-        key: 'apiKey',
-        label: 'API Key',
-        type: 'password',
-        required: true,
-        placeholder: 'Enter your API key',
-        description: 'API key for the service'
-      }
-    ],
-    nameSuggestions: ['service-prod', 'service-dev', 'api-key']
-  },
-
-  'webhook-secret': {
-    type: 'single_field',
-    label: 'Webhook Secret',
-    description: 'Webhook signing secret for signature validation',
-    fields: [
-      {
-        key: 'signingSecret',
-        label: 'Signing Secret',
-        type: 'password',
-        required: true,
-        placeholder: 'whsec_...',
-        description: 'Webhook signing secret from provider dashboard'
-      }
-    ],
-    nameSuggestions: ['my-org-cal-com-webhook', 'my-org-stripe-webhook', 'my-org-signature-api-webhook']
-  },
-
-  'api-key-secret': {
-    type: 'api-key-secret',
-    label: 'API Key + Secret',
-    description: 'API key and secret pair authentication',
-    fields: [
-      {
-        key: 'apiKey',
-        label: 'API Key',
-        type: 'password',
-        required: true
-      },
-      {
-        key: 'apiSecret',
-        label: 'API Secret',
-        type: 'password',
-        required: true
-      }
-    ],
-    nameSuggestions: []
-  }
-}
-
-/**
- * Get credential schema by type
- * @param type - Credential type identifier
- * @returns Validated credential schema
- * @throws ZodError if schema is malformed
- */
-export function getCredentialSchema(type: string): CredentialSchema {
-  const schema = CREDENTIAL_SCHEMAS[type] || CREDENTIAL_SCHEMAS['api-key']
-  return CredentialSchemaZod.parse(schema)
-}
-
-/**
- * List all available credential types (for frontend dropdown)
- * @returns Array of credential schemas
- */
-export function listCredentialSchemas(): CredentialSchema[] {
-  return Object.values(CREDENTIAL_SCHEMAS)
-}
-
-/**
- * Get all credential type identifiers
- * @returns Array of type strings
- */
-export function getCredentialTypes(): string[] {
-  return Object.keys(CREDENTIAL_SCHEMAS)
-}
+import { z } from 'zod'
+
+/**
+ * Credential field definition
+ */
+export interface CredentialField {
+  key: string
+  label: string
+  type: 'password' | 'text'
+  required: boolean
+  placeholder?: string
+  description?: string
+}
+
+/**
+ * Credential schema definition
+ */
+export interface CredentialSchema {
+  type: string
+  label: string
+  description: string
+  fields?: CredentialField[]
+  docsUrl?: string
+  nameSuggestions: string[]
+  oauthProvider?: string // For OAuth types
+}
+
+/**
+ * Zod schemas for runtime validation
+ */
+const CredentialFieldSchema = z.object({
+  key: z.string(),
+  label: z.string(),
+  type: z.enum(['password', 'text']),
+  required: z.boolean(),
+  placeholder: z.string().optional(),
+  description: z.string().optional()
+})
+
+const CredentialSchemaZod = z.object({
+  type: z.string(),
+  label: z.string(),
+  description: z.string(),
+  fields: z.array(CredentialFieldSchema).optional(),
+  docsUrl: z.string().url().optional(),
+  nameSuggestions: z.array(z.string()),
+  oauthProvider: z.string().optional()
+})
+
+/**
+ * Credential Schema Registry
+ *
+ * Add new integration = add schema object here (no modal changes needed)
+ *
+ * Schema types:
+ * - oauth: OAuth-based authentication (handled via OAuth flow)
+ * - single_field: Single API key field (generic)
+ */
+export const CREDENTIAL_SCHEMAS: Record<string, CredentialSchema> = {
+  'google-sheets': {
+    type: 'oauth',
+    label: 'Google Sheets',
+    description: 'Google Sheets OAuth integration',
+    oauthProvider: 'google-sheets',
+    nameSuggestions: ['google-sheets-prod', 'google-sheets-dev', 'sheets-workspace']
+  },
+
+  dropbox: {
+    type: 'oauth',
+    label: 'Dropbox',
+    description: 'Dropbox OAuth integration',
+    oauthProvider: 'dropbox',
+    nameSuggestions: ['dropbox-prod', 'dropbox-dev', 'elevasis-dropbox']
+  },
+
+  oauth: {
+    type: 'oauth',
+    label: 'OAuth',
+    description: 'Generic OAuth credential',
+    nameSuggestions: []
+  },
+
+  'api-key': {
+    type: 'single_field',
+    label: 'API Key',
+    description: 'Single-field API key credential',
+    fields: [
+      {
+        key: 'apiKey',
+        label: 'API Key',
+        type: 'password',
+        required: true,
+        placeholder: 'Enter your API key',
+        description: 'API key for the service'
+      }
+    ],
+    nameSuggestions: ['service-prod', 'service-dev', 'api-key']
+  },
+
+  'webhook-secret': {
+    type: 'single_field',
+    label: 'Webhook Secret',
+    description: 'Webhook signing secret for signature validation',
+    fields: [
+      {
+        key: 'signingSecret',
+        label: 'Signing Secret',
+        type: 'password',
+        required: true,
+        placeholder: 'whsec_...',
+        description: 'Webhook signing secret from provider dashboard'
+      }
+    ],
+    nameSuggestions: ['my-org-cal-com-webhook', 'my-org-stripe-webhook', 'my-org-signature-api-webhook']
+  },
+
+  'api-key-secret': {
+    type: 'api-key-secret',
+    label: 'API Key + Secret',
+    description: 'API key and secret pair authentication',
+    fields: [
+      {
+        key: 'apiKey',
+        label: 'API Key',
+        type: 'password',
+        required: true
+      },
+      {
+        key: 'apiSecret',
+        label: 'API Secret',
+        type: 'password',
+        required: true
+      }
+    ],
+    nameSuggestions: []
+  },
+
+  apify: {
+    type: 'single_field',
+    label: 'Apify',
+    description: 'Apify API token for running web-scraping actors (e.g. website crawl, Google Places scrape).',
+    fields: [
+      {
+        key: 'apiKey',
+        label: 'API Token',
+        type: 'password',
+        required: true,
+        placeholder: 'apify_api_...',
+        description: 'Personal API token from https://console.apify.com/account/integrations'
+      }
+    ],
+    docsUrl: 'https://docs.apify.com/platform/integrations/api',
+    nameSuggestions: ['elevasis-apify', 'apify-prod', 'apify-dev']
+  },
+
+  clickup: {
+    type: 'single_field',
+    label: 'ClickUp',
+    description: 'ClickUp personal API token for creating tasks in tenant-managed ClickUp workspaces.',
+    fields: [
+      {
+        key: 'apiToken',
+        label: 'API Token',
+        type: 'password',
+        required: true,
+        placeholder: 'pk_...',
+        description: 'Personal API token from ClickUp settings. Personal tokens start with pk_.'
+      }
+    ],
+    docsUrl: 'https://developer.clickup.com/docs/authentication',
+    nameSuggestions: ['clickup-demo', 'clickup-prod', 'clickup-dev']
+  }
+}
+
+/**
+ * Get credential schema by type
+ * @param type - Credential type identifier
+ * @returns Validated credential schema
+ * @throws ZodError if schema is malformed
+ */
+export function getCredentialSchema(type: string): CredentialSchema {
+  const schema = CREDENTIAL_SCHEMAS[type] || CREDENTIAL_SCHEMAS['api-key']
+  return CredentialSchemaZod.parse(schema)
+}
+
+/**
+ * List all available credential types (for frontend dropdown)
+ * @returns Array of credential schemas
+ */
+export function listCredentialSchemas(): CredentialSchema[] {
+  return Object.values(CREDENTIAL_SCHEMAS)
+}
+
+/**
+ * Get all credential type identifiers
+ * @returns Array of type strings
+ */
+export function getCredentialTypes(): string[] {
+  return Object.keys(CREDENTIAL_SCHEMAS)
+}

package/src/organization-model/__tests__/graph.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { buildOrganizationGraph } from '../graph/build'
+import { CAPABILITY_REGISTRY } from '../domains/prospecting'
 import { resolveOrganizationModel } from '../resolve'
 
 describe('organization graph', () => {
@@ -11,7 +12,9 @@ describe('organization graph', () => {
       sourceId: 'sales.crm',
       label: 'CRM'
     })
-    expect(graph.edges.find((edge) => edge.sourceId === 'feature:sales' && edge.targetId === 'feature:sales.crm')).toMatchObject({
+    expect(
+      graph.edges.find((edge) => edge.sourceId === 'feature:sales' && edge.targetId === 'feature:sales.crm')
+    ).toMatchObject({
       kind: 'contains'
     })
   })
@@ -74,9 +77,112 @@ describe('organization graph', () => {
       kind: 'resource',
       label: 'missing-resource'
     })
-    expect(graph.edges.find((edge) => edge.id.includes('uses'))).toMatchObject({
+    expect(graph.edges.find((edge) => edge.kind === 'references' && edge.relationshipType === 'uses')).toMatchObject({
       kind: 'references',
       relationshipType: 'uses'
     })
   })
+
+  it('projects stage nodes from prospecting lifecycle stages', () => {
+    const graph = buildOrganizationGraph({
+      organizationModel: resolveOrganizationModel({
+        features: [{ id: 'operations', label: 'Operations', enabled: true, path: '/operations' }]
+      })
+    })
+
+    const stageNodes = graph.nodes.filter((node) => node.kind === 'stage')
+    expect(stageNodes.length).toBeGreaterThan(0)
+
+    const populated = graph.nodes.find((node) => node.id === 'stage:populated')
+    expect(populated).toMatchObject({ kind: 'stage', sourceId: 'populated' })
+    expect(populated?.label).toBeTruthy()
+
+    expect(graph.edges.find((edge) => edge.kind === 'contains' && edge.targetId === 'stage:populated')).toMatchObject({
+      sourceId: 'organization-model'
+    })
+  })
+
+  it('projects capability nodes from CAPABILITY_REGISTRY with maps_to edges to resources', () => {
+    const graph = buildOrganizationGraph({
+      organizationModel: resolveOrganizationModel({
+        features: [{ id: 'operations', label: 'Operations', enabled: true, path: '/operations' }]
+      })
+    })
+
+    const capabilityNodes = graph.nodes.filter((node) => node.kind === 'capability')
+    expect(capabilityNodes).toHaveLength(CAPABILITY_REGISTRY.length)
+
+    const sample = CAPABILITY_REGISTRY[0]
+    const node = graph.nodes.find((n) => n.id === `capability:${sample.id}`)
+    expect(node).toMatchObject({
+      kind: 'capability',
+      sourceId: sample.id,
+      label: sample.label,
+      description: sample.description
+    })
+
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'maps_to' &&
+          edge.sourceId === `capability:${sample.id}` &&
+          edge.targetId === `resource:${sample.resourceId}`
+      )
+    ).toBeDefined()
+
+    expect(graph.nodes.find((n) => n.id === `resource:${sample.resourceId}`)).toBeDefined()
+  })
+
+  it('emits uses edges from stages to capabilities for every prospecting build-template step', () => {
+    const model = resolveOrganizationModel({
+      features: [{ id: 'operations', label: 'Operations', enabled: true, path: '/operations' }]
+    })
+    const graph = buildOrganizationGraph({ organizationModel: model })
+
+    for (const template of model.prospecting.buildTemplates) {
+      for (const step of template.steps) {
+        const stageNodeId = `stage:${step.stageKey}`
+        const capNodeId = `capability:${step.capabilityKey}`
+        expect(
+          graph.edges.find(
+            (edge) =>
+              edge.kind === 'uses' &&
+              edge.sourceId === stageNodeId &&
+              edge.targetId === capNodeId &&
+              edge.id.includes(step.id)
+          ),
+          `${template.id}.${step.id}: ${stageNodeId} uses ${capNodeId}`
+        ).toBeDefined()
+      }
+    }
+  })
+
+  it('emits references edges between stages for every step dependsOn link', () => {
+    const model = resolveOrganizationModel({
+      features: [{ id: 'operations', label: 'Operations', enabled: true, path: '/operations' }]
+    })
+    const graph = buildOrganizationGraph({ organizationModel: model })
+
+    for (const template of model.prospecting.buildTemplates) {
+      const stepById = new Map(template.steps.map((s) => [s.id, s]))
+      for (const step of template.steps) {
+        for (const depId of step.dependsOn ?? []) {
+          const depStep = stepById.get(depId)
+          if (!depStep) continue
+          const stageNodeId = `stage:${step.stageKey}`
+          const depStageNodeId = `stage:${depStep.stageKey}`
+          expect(
+            graph.edges.find(
+              (edge) =>
+                edge.kind === 'references' &&
+                edge.sourceId === stageNodeId &&
+                edge.targetId === depStageNodeId &&
+                edge.id.includes(step.id)
+            ),
+            `${template.id}.${step.id} dependsOn ${depId}`
+          ).toBeDefined()
+        }
+      }
+    }
+  })
 })

package/src/organization-model/__tests__/prospecting-ssot.test.ts

@@ -1,14 +1,11 @@
 import { describe, expect, it } from 'vitest'
 import { LEAD_GEN_STAGE_CATALOG } from '../domains/sales'
-import {
-  CAPABILITY_REGISTRY,
-  DEFAULT_ORGANIZATION_MODEL_PROSPECTING,
-  PROSPECTING_STEPS
-} from '../domains/prospecting'
+import { CAPABILITY_REGISTRY, DEFAULT_ORGANIZATION_MODEL_PROSPECTING, PROSPECTING_STEPS } from '../domains/prospecting'
 
-const EXPECTED_CAPABILITY_REGISTRY = {
+const EXPECTED_CAPABILITY_RESOURCE_BY_ID: Record<string, string> = {
   'lead-gen.company.source': 'lgn-import-workflow',
   'lead-gen.company.apollo-import': 'lgn-01c-apollo-import-workflow',
+  'lead-gen.company.apify-crawl': 'lgn-02a-apify-website-crawl-workflow',
   'lead-gen.contact.discover': 'lgn-04-email-discovery-workflow',
   'lead-gen.contact.verify-email': 'lgn-05-email-verification-workflow',
   'lead-gen.company.website-extract': 'lgn-02-website-extract-workflow',
@@ -28,7 +25,9 @@ describe('prospecting organization-model SSOT', () => {
       label: 'Decision-makers found',
       description: 'Decision-maker contacts discovered and attached to a qualified company.',
       order: 6,
-      entity: 'company'
+      entity: 'company',
+      recordEntity: 'contact',
+      recordStageKey: 'discovered'
     })
   })
 
@@ -56,7 +55,7 @@ describe('prospecting organization-model SSOT', () => {
   })
 
   it('uses registered capabilities for every prospecting step', () => {
-    const capabilityKeys = new Set(Object.keys(CAPABILITY_REGISTRY))
+    const capabilityKeys = new Set(CAPABILITY_REGISTRY.map((c) => c.id))
 
     for (const templateSteps of Object.values(PROSPECTING_STEPS)) {
       for (const step of Object.values(templateSteps)) {
@@ -67,12 +66,12 @@ describe('prospecting organization-model SSOT', () => {
 
   it('derives prospecting lifecycle stages from the stage catalog by entity', () => {
     const expectedCompanyStages = Object.values(LEAD_GEN_STAGE_CATALOG)
-      .filter((stage) => stage.entity === 'company')
+      .filter((stage) => stage.entity === 'company' || stage.additionalEntities?.includes('company'))
       .sort((a, b) => a.order - b.order)
       .map(({ key, label, order }) => ({ id: key, label, order }))
 
     const expectedContactStages = Object.values(LEAD_GEN_STAGE_CATALOG)
-      .filter((stage) => stage.entity === 'contact')
+      .filter((stage) => stage.entity === 'contact' || stage.additionalEntities?.includes('contact'))
       .sort((a, b) => a.order - b.order)
       .map(({ key, label, order }) => ({ id: key, label, order }))
 
@@ -88,7 +87,8 @@ describe('prospecting organization-model SSOT', () => {
   })
 
   it('covers all known lead-gen capability registry entries', () => {
-    expect(CAPABILITY_REGISTRY).toEqual(EXPECTED_CAPABILITY_REGISTRY)
-    expect(Object.keys(CAPABILITY_REGISTRY)).toHaveLength(12)
+    expect(CAPABILITY_REGISTRY).toHaveLength(13)
+    const actualResourceById = Object.fromEntries(CAPABILITY_REGISTRY.map((c) => [c.id, c.resourceId]))
+    expect(actualResourceById).toEqual(EXPECTED_CAPABILITY_RESOURCE_BY_ID)
   })
 })