@elevasis/core 0.2.1 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elevasis/core",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "license": "MIT",
   "description": "Minimal shared constants across Elevasis monorepo",
   "sideEffects": false,

package/src/README.md

@@ -23,7 +23,7 @@ Within the monorepo, the internal `@repo/core` package exposes additional subpat
 - `@repo/core/server` - Node.js-only helpers and services.
 - `@repo/core/platform` - shared constants, utilities, registry, SSE, and API types.
 - `@repo/core/auth` - multi-tenancy types for organizations, users, memberships, invitations, and credentials.
-- `@repo/core/execution` - workflow, agent, scheduler, calibration, and execution-interface contracts.
+- `@repo/core/execution` - workflow, agent, scheduler, and execution-interface contracts.
 - `@repo/core/commands` - command queue types and schemas.
 - `@repo/core/operations` - sessions, notifications, observability, activities, triggers, and debug logs.
 - `@repo/core/supabase` - generated database types and helpers.

package/src/__tests__/template-foundations-compatibility.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vitest'
+import { DELIVERY_PROJECTS_VIEW_CAPABILITY_ID, PROJECTS_FEATURE_ID } from '../organization-model/published'
 import {
   getOrganizationSurface,
   homeLabel,
@@ -14,18 +15,18 @@ describe('template foundations compatibility', () => {
     expect(foundationOrganizationModel.navigation.defaultSurfaceId).toBe('operations')
     expect(getOrganizationSurface('operations')).toMatchObject({
       id: 'operations',
-      label: 'Operations',
+      label: 'Organization Graph',
       path: '/operations',
       surfaceType: 'graph',
-      featureKey: 'operations'
+      featureId: 'operations'
     })
 
     expect(getOrganizationSurface('operations.organization-graph')).toMatchObject({
       id: 'operations.organization-graph',
-      label: 'Operations',
+      label: 'Organization Graph',
       path: '/operations',
       surfaceType: 'graph',
-      featureKey: 'operations'
+      featureId: 'operations'
     })
   })
 
@@ -33,45 +34,41 @@ describe('template foundations compatibility', () => {
     const legacySurfaces = [
       {
         id: 'operations',
-        label: 'Operations',
+        label: 'Organization Graph',
         surfaceType: 'graph',
-        expectedFeatureKey: 'operations',
+        expectedFeatureId: 'operations',
         expectedIcon: 'operations',
         expectedPath: '/operations',
-        expectedDomainIds: ['operations'],
         expectedEntityIds: [],
-        expectedCapabilityIds: ['operations.organization-graph', 'operations.command-view']
+        expectedCapabilityIds: ['operations.organization-graph']
       },
       {
-        id: 'projects',
+        id: PROJECTS_FEATURE_ID,
         label: 'Projects',
         surfaceType: 'list',
-        expectedFeatureKey: 'projects',
+        expectedFeatureId: PROJECTS_FEATURE_ID,
         expectedIcon: 'projects',
         expectedPath: '/projects',
-        expectedDomainIds: ['delivery'],
         expectedEntityIds: ['delivery.project'],
-        expectedCapabilityIds: ['delivery.projects.view']
+        expectedCapabilityIds: [DELIVERY_PROJECTS_VIEW_CAPABILITY_ID]
       },
       {
         id: 'lead-gen',
-        label: 'Lead Gen',
+        label: 'Lists',
         surfaceType: 'list',
-        expectedFeatureKey: 'lead-gen',
+        expectedFeatureId: 'lead-gen',
         expectedIcon: 'lead-gen',
-        expectedPath: '/lead-gen',
-        expectedDomainIds: ['lead-gen'],
+        expectedPath: '/lead-gen/lists',
         expectedEntityIds: ['leadgen.list'],
         expectedCapabilityIds: ['leadgen.lists.manage']
       },
       {
         id: 'crm',
-        label: 'CRM',
+        label: 'Pipeline',
         surfaceType: 'graph',
-        expectedFeatureKey: 'crm',
+        expectedFeatureId: 'crm',
         expectedIcon: 'crm',
-        expectedPath: '/crm',
-        expectedDomainIds: ['crm'],
+        expectedPath: '/crm/pipeline',
         expectedEntityIds: ['crm.deal'],
         expectedCapabilityIds: ['crm.pipeline.manage']
       }
@@ -86,8 +83,7 @@ describe('template foundations compatibility', () => {
         path: surface.expectedPath,
         surfaceType: surface.surfaceType,
         icon: surface.expectedIcon,
-        featureKey: surface.expectedFeatureKey,
-        domainIds: surface.expectedDomainIds,
+        featureId: surface.expectedFeatureId,
         entityIds: surface.expectedEntityIds,
         resourceIds: [],
         capabilityIds: surface.expectedCapabilityIds
@@ -96,20 +92,16 @@ describe('template foundations compatibility', () => {
   })
 
   it('maps grouped core features onto the legacy template feature vocabulary', () => {
-    expect(foundationOrganizationModel.features.enabled.acquisition).toBe(true)
-    expect(foundationOrganizationModel.features.enabled.delivery).toBe(true)
-    expect(foundationOrganizationModel.features.enabled.crm).toBe(
-      foundationOrganizationModel.features.enabled.acquisition
-    )
-    expect(foundationOrganizationModel.features.enabled['lead-gen']).toBe(
-      foundationOrganizationModel.features.enabled.acquisition
-    )
-    expect(foundationOrganizationModel.features.enabled.projects).toBe(
-      foundationOrganizationModel.features.enabled.delivery
-    )
+    const features = foundationOrganizationModel.features as Array<{ id: string; label: string; enabled: boolean }>
+    const featureById = (id: string) => features.find((f) => f.id === id)
 
-    expect(foundationOrganizationModel.features.labels.crm).toBe('CRM')
-    expect(foundationOrganizationModel.features.labels['lead-gen']).toBe('Lead Gen')
-    expect(foundationOrganizationModel.features.labels.projects).toBe('Projects')
+    expect(featureById('crm')?.enabled).toBe(true)
+    expect(featureById('lead-gen')?.enabled).toBe(true)
+    expect(featureById('projects')?.enabled).toBe(true)
+    expect(featureById('operations')?.enabled).toBe(true)
+
+    expect(featureById('crm')?.label).toBe('CRM')
+    expect(featureById('lead-gen')?.label).toBe('Lead Gen')
+    expect(featureById('projects')?.label).toBe('Projects')
   })
 })

package/src/auth/multi-tenancy/types.ts

@@ -9,18 +9,11 @@
 
 /**
  * Per-user-per-org config (stored in org_memberships.config)
- * Controls which features a specific member can access within their org
- * Valid feature keys: operations, monitoring, acquisition, delivery, calibration, seo
+ * Controls which features a specific member can access within their org.
+ * Keys are feature IDs from the organization model (e.g. crm, lead-gen, projects, seo).
  */
 export interface MembershipFeatureConfig {
-  features?: {
-    operations?: boolean
-    monitoring?: boolean
-    acquisition?: boolean
-    delivery?: boolean
-    calibration?: boolean
-    seo?: boolean
-  }
+  features?: Record<string, boolean>
 }
 
 /**
@@ -37,7 +30,7 @@ export interface UserConfig {
       | 'aurora'
       | 'rose-gold'
       | 'midnight'
-      | 'ember'
+      | 'titanium'
       | 'obsidian'
       | 'honey'
       | 'abyss'

package/src/auth/multi-tenancy/users/api-schemas.ts

@@ -103,7 +103,7 @@ export const UpdateMyProfileSchema = z
                 'aurora',
                 'rose-gold',
                 'midnight',
-                'ember',
+                'titanium',
                 'obsidian',
                 'honey',
                 'abyss',

package/src/business/base-entities.test.ts

@@ -0,0 +1,481 @@
+/**
+ * Base Entity Contracts - Unit Tests
+ *
+ * Verifies that:
+ * - Base interfaces accept generic TMeta narrowing
+ * - Zod schemas parse valid data correctly
+ * - Schema extension via .extend() works for client metadata narrowing
+ * - Default metadata falls back to Record<string, unknown>
+ */
+
+import { describe, it, expect } from 'vitest'
+import { z } from 'zod'
+import {
+  BaseProjectSchema,
+  BaseMilestoneSchema,
+  BaseTaskSchema,
+  BaseDealSchema,
+  BaseCompanySchema,
+  BaseContactSchema,
+  type BaseProject,
+  type BaseMilestone,
+  type BaseTask,
+  type BaseDeal,
+  type BaseCompany,
+  type BaseContact
+} from './base-entities'
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+const ORG_ID = '00000000-0000-0000-0000-000000000001'
+const TIMESTAMPS = {
+  createdAt: '2026-04-17T00:00:00.000Z',
+  updatedAt: '2026-04-17T00:00:00.000Z'
+}
+
+// ---------------------------------------------------------------------------
+// BaseProjectSchema
+// ---------------------------------------------------------------------------
+
+describe('BaseProjectSchema', () => {
+  const validProject = {
+    id: '00000000-0000-0000-0000-000000000010',
+    organizationId: ORG_ID,
+    name: 'Website Rebuild',
+    kind: 'client_engagement',
+    status: 'active',
+    description: 'Rebuild the client website.',
+    metadata: { budget: 50000 },
+    ...TIMESTAMPS
+  }
+
+  it('parses a valid project', () => {
+    const result = BaseProjectSchema.safeParse(validProject)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.name).toBe('Website Rebuild')
+      expect(result.data.kind).toBe('client_engagement')
+      expect(result.data.status).toBe('active')
+    }
+  })
+
+  it('accepts null description', () => {
+    const result = BaseProjectSchema.safeParse({ ...validProject, description: null })
+    expect(result.success).toBe(true)
+  })
+
+  it('defaults metadata to empty object when omitted', () => {
+    const { metadata: _meta, ...withoutMeta } = validProject
+    const result = BaseProjectSchema.safeParse(withoutMeta)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.metadata).toEqual({})
+    }
+  })
+
+  it('rejects missing required fields', () => {
+    const result = BaseProjectSchema.safeParse({ id: 'x', organizationId: ORG_ID })
+    expect(result.success).toBe(false)
+  })
+
+  it('supports schema extension for narrowed metadata', () => {
+    const ProjectMetaSchema = z.object({ budget: z.number(), riskScore: z.enum(['low', 'medium', 'high']) })
+    const NarrowedProjectSchema = BaseProjectSchema.extend({ metadata: ProjectMetaSchema })
+
+    const result = NarrowedProjectSchema.safeParse({
+      ...validProject,
+      metadata: { budget: 75000, riskScore: 'low' }
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.metadata.budget).toBe(75000)
+      expect(result.data.metadata.riskScore).toBe('low')
+    }
+  })
+
+  it('rejects invalid narrowed metadata via extended schema', () => {
+    const ProjectMetaSchema = z.object({ budget: z.number() })
+    const NarrowedProjectSchema = BaseProjectSchema.extend({ metadata: ProjectMetaSchema })
+
+    const result = NarrowedProjectSchema.safeParse({
+      ...validProject,
+      metadata: { budget: 'not-a-number' }
+    })
+    expect(result.success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// BaseMilestoneSchema
+// ---------------------------------------------------------------------------
+
+describe('BaseMilestoneSchema', () => {
+  const validMilestone = {
+    id: '00000000-0000-0000-0000-000000000020',
+    organizationId: ORG_ID,
+    projectId: '00000000-0000-0000-0000-000000000010',
+    name: 'Phase 1 Complete',
+    status: 'upcoming',
+    description: null,
+    metadata: {},
+    ...TIMESTAMPS
+  }
+
+  it('parses a valid milestone', () => {
+    const result = BaseMilestoneSchema.safeParse(validMilestone)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.projectId).toBe('00000000-0000-0000-0000-000000000010')
+      expect(result.data.status).toBe('upcoming')
+    }
+  })
+
+  it('defaults metadata to empty object when omitted', () => {
+    const { metadata: _meta, ...withoutMeta } = validMilestone
+    const result = BaseMilestoneSchema.safeParse(withoutMeta)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.metadata).toEqual({})
+    }
+  })
+
+  it('supports schema extension for narrowed metadata', () => {
+    const MilestoneMetaSchema = z.object({ deliverables: z.array(z.string()) })
+    const NarrowedSchema = BaseMilestoneSchema.extend({ metadata: MilestoneMetaSchema })
+
+    const result = NarrowedSchema.safeParse({
+      ...validMilestone,
+      metadata: { deliverables: ['doc-1', 'doc-2'] }
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.metadata.deliverables).toHaveLength(2)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// BaseTaskSchema
+// ---------------------------------------------------------------------------
+
+describe('BaseTaskSchema', () => {
+  const validTask = {
+    id: '00000000-0000-0000-0000-000000000030',
+    organizationId: ORG_ID,
+    projectId: '00000000-0000-0000-0000-000000000010',
+    name: 'Write API docs',
+    status: 'planned',
+    type: 'documentation',
+    description: 'Document all endpoints.',
+    metadata: { priority: 'high' },
+    ...TIMESTAMPS
+  }
+
+  it('parses a valid task', () => {
+    const result = BaseTaskSchema.safeParse(validTask)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.type).toBe('documentation')
+      expect(result.data.status).toBe('planned')
+    }
+  })
+
+  it('accepts null description', () => {
+    const result = BaseTaskSchema.safeParse({ ...validTask, description: null })
+    expect(result.success).toBe(true)
+  })
+
+  it('supports schema extension for narrowed metadata', () => {
+    const TaskMetaSchema = z.object({ storyPoints: z.number().int(), sprint: z.string().optional() })
+    const NarrowedSchema = BaseTaskSchema.extend({ metadata: TaskMetaSchema })
+
+    const result = NarrowedSchema.safeParse({
+      ...validTask,
+      metadata: { storyPoints: 3, sprint: 'S4' }
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.metadata.storyPoints).toBe(3)
+      expect(result.data.metadata.sprint).toBe('S4')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// BaseDealSchema
+// ---------------------------------------------------------------------------
+
+describe('BaseDealSchema', () => {
+  const validDeal = {
+    id: '00000000-0000-0000-0000-000000000040',
+    organizationId: ORG_ID,
+    contactEmail: 'prospect@example.com',
+    stage: 'proposal',
+    metadata: {},
+    ...TIMESTAMPS
+  }
+
+  it('parses a valid deal', () => {
+    const result = BaseDealSchema.safeParse(validDeal)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.contactEmail).toBe('prospect@example.com')
+      expect(result.data.stage).toBe('proposal')
+    }
+  })
+
+  it('accepts null stage', () => {
+    const result = BaseDealSchema.safeParse({ ...validDeal, stage: null })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.stage).toBeNull()
+    }
+  })
+
+  it('defaults metadata to empty object when omitted', () => {
+    const { metadata: _meta, ...withoutMeta } = validDeal
+    const result = BaseDealSchema.safeParse(withoutMeta)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.metadata).toEqual({})
+    }
+  })
+
+  it('supports schema extension for narrowed metadata', () => {
+    const DealMetaSchema = z.object({ initialFee: z.number(), monthlyFee: z.number() })
+    const NarrowedSchema = BaseDealSchema.extend({ metadata: DealMetaSchema })
+
+    const result = NarrowedSchema.safeParse({
+      ...validDeal,
+      metadata: { initialFee: 2000, monthlyFee: 500 }
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.metadata.initialFee).toBe(2000)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// BaseCompanySchema
+// ---------------------------------------------------------------------------
+
+describe('BaseCompanySchema', () => {
+  const validCompany = {
+    id: '00000000-0000-0000-0000-000000000050',
+    organizationId: ORG_ID,
+    name: 'Acme Corp',
+    domain: 'acme.com',
+    status: 'active',
+    metadata: {},
+    ...TIMESTAMPS
+  }
+
+  it('parses a valid company', () => {
+    const result = BaseCompanySchema.safeParse(validCompany)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.name).toBe('Acme Corp')
+      expect(result.data.domain).toBe('acme.com')
+    }
+  })
+
+  it('accepts null domain', () => {
+    const result = BaseCompanySchema.safeParse({ ...validCompany, domain: null })
+    expect(result.success).toBe(true)
+  })
+
+  it('supports schema extension for narrowed metadata', () => {
+    const CompanyMetaSchema = z.object({ reviewCount: z.number().int(), rating: z.number() })
+    const NarrowedSchema = BaseCompanySchema.extend({ metadata: CompanyMetaSchema })
+
+    const result = NarrowedSchema.safeParse({
+      ...validCompany,
+      metadata: { reviewCount: 120, rating: 4.7 }
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.metadata.reviewCount).toBe(120)
+      expect(result.data.metadata.rating).toBe(4.7)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// BaseContactSchema
+// ---------------------------------------------------------------------------
+
+describe('BaseContactSchema', () => {
+  const validContact = {
+    id: '00000000-0000-0000-0000-000000000060',
+    organizationId: ORG_ID,
+    email: 'jane@example.com',
+    firstName: 'Jane',
+    lastName: 'Doe',
+    status: 'active',
+    metadata: {},
+    ...TIMESTAMPS
+  }
+
+  it('parses a valid contact', () => {
+    const result = BaseContactSchema.safeParse(validContact)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.email).toBe('jane@example.com')
+      expect(result.data.firstName).toBe('Jane')
+    }
+  })
+
+  it('accepts null firstName and lastName', () => {
+    const result = BaseContactSchema.safeParse({ ...validContact, firstName: null, lastName: null })
+    expect(result.success).toBe(true)
+  })
+
+  it('supports schema extension for narrowed metadata', () => {
+    const ContactMetaSchema = z.object({ linkedinScore: z.number().optional(), tags: z.array(z.string()) })
+    const NarrowedSchema = BaseContactSchema.extend({ metadata: ContactMetaSchema })
+
+    const result = NarrowedSchema.safeParse({
+      ...validContact,
+      metadata: { tags: ['enterprise', 'warm-lead'], linkedinScore: 8 }
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.metadata.tags).toContain('enterprise')
+      expect(result.data.metadata.linkedinScore).toBe(8)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// TypeScript generic interface narrowing (compile-time — exercised at runtime)
+// ---------------------------------------------------------------------------
+
+describe('BaseProject<TMeta> generic interface', () => {
+  it('accepts unnarrowed metadata as Record<string, unknown>', () => {
+    const project: BaseProject = {
+      id: '00000000-0000-0000-0000-000000000010',
+      organizationId: ORG_ID,
+      name: 'Generic Project',
+      kind: 'internal',
+      status: 'active',
+      description: null,
+      metadata: { anything: true },
+      ...TIMESTAMPS
+    }
+    expect(project.metadata['anything']).toBe(true)
+  })
+
+  it('accepts narrowed metadata type', () => {
+    type ProjectMeta = { budget: number; riskScore: 'low' | 'medium' | 'high' }
+    const project: BaseProject<ProjectMeta> = {
+      id: '00000000-0000-0000-0000-000000000011',
+      organizationId: ORG_ID,
+      name: 'Budget Project',
+      kind: 'client_engagement',
+      status: 'on_track',
+      description: 'A budgeted project',
+      metadata: { budget: 100000, riskScore: 'low' },
+      ...TIMESTAMPS
+    }
+    expect(project.metadata.budget).toBe(100000)
+    expect(project.metadata.riskScore).toBe('low')
+  })
+})
+
+describe('BaseDeal<TMeta> generic interface', () => {
+  it('accepts unnarrowed metadata', () => {
+    const deal: BaseDeal = {
+      id: '00000000-0000-0000-0000-000000000040',
+      organizationId: ORG_ID,
+      contactEmail: 'test@example.com',
+      stage: 'interested',
+      metadata: {},
+      ...TIMESTAMPS
+    }
+    expect(deal.stage).toBe('interested')
+  })
+
+  it('accepts narrowed metadata with deal financials', () => {
+    type DealMeta = { contractValue: number; currency: string }
+    const deal: BaseDeal<DealMeta> = {
+      id: '00000000-0000-0000-0000-000000000041',
+      organizationId: ORG_ID,
+      contactEmail: 'client@bigco.com',
+      stage: 'closing',
+      metadata: { contractValue: 24000, currency: 'USD' },
+      ...TIMESTAMPS
+    }
+    expect(deal.metadata.contractValue).toBe(24000)
+  })
+})
+
+describe('BaseMilestone<TMeta> generic interface', () => {
+  it('accepts narrowed metadata', () => {
+    type MilestoneMeta = { deliverables: string[] }
+    const milestone: BaseMilestone<MilestoneMeta> = {
+      id: '00000000-0000-0000-0000-000000000020',
+      organizationId: ORG_ID,
+      projectId: '00000000-0000-0000-0000-000000000010',
+      name: 'Launch',
+      status: 'in_progress',
+      description: null,
+      metadata: { deliverables: ['landing-page', 'email-campaign'] },
+      ...TIMESTAMPS
+    }
+    expect(milestone.metadata.deliverables).toHaveLength(2)
+  })
+})
+
+describe('BaseTask<TMeta> generic interface', () => {
+  it('accepts narrowed metadata', () => {
+    type TaskMeta = { storyPoints: number }
+    const task: BaseTask<TaskMeta> = {
+      id: '00000000-0000-0000-0000-000000000030',
+      organizationId: ORG_ID,
+      projectId: '00000000-0000-0000-0000-000000000010',
+      name: 'Deploy to prod',
+      status: 'in_progress',
+      type: 'code',
+      description: null,
+      metadata: { storyPoints: 5 },
+      ...TIMESTAMPS
+    }
+    expect(task.metadata.storyPoints).toBe(5)
+  })
+})
+
+describe('BaseCompany<TMeta> generic interface', () => {
+  it('accepts narrowed metadata', () => {
+    type CompanyMeta = { verticalScore: number }
+    const company: BaseCompany<CompanyMeta> = {
+      id: '00000000-0000-0000-0000-000000000050',
+      organizationId: ORG_ID,
+      name: 'Tech Startup',
+      domain: 'techstartup.io',
+      status: 'active',
+      metadata: { verticalScore: 92 },
+      ...TIMESTAMPS
+    }
+    expect(company.metadata.verticalScore).toBe(92)
+  })
+})
+
+describe('BaseContact<TMeta> generic interface', () => {
+  it('accepts narrowed metadata', () => {
+    type ContactMeta = { personalizationScore: number; openingLine: string }
+    const contact: BaseContact<ContactMeta> = {
+      id: '00000000-0000-0000-0000-000000000060',
+      organizationId: ORG_ID,
+      email: 'ceo@example.com',
+      firstName: 'Alex',
+      lastName: 'Smith',
+      status: 'active',
+      metadata: { personalizationScore: 87, openingLine: 'Loved your post on AI automation.' },
+      ...TIMESTAMPS
+    }
+    expect(contact.metadata.personalizationScore).toBe(87)
+  })
+})