@lssm/example.crm-pipeline 0.0.0-canary-20251206160926

package/src/entities/task.ts

@@ -0,0 +1,132 @@
+import { defineEntity, defineEntityEnum, field, index } from '@lssm/lib.schema';
+
+/**
+ * Task type enum.
+ */
+export const TaskTypeEnum = defineEntityEnum({
+  name: 'TaskType',
+  values: ['CALL', 'EMAIL', 'MEETING', 'TODO', 'FOLLOW_UP', 'OTHER'] as const,
+  schema: 'crm',
+  description: 'Type of CRM task.',
+});
+
+/**
+ * Task priority enum.
+ */
+export const TaskPriorityEnum = defineEntityEnum({
+  name: 'TaskPriority',
+  values: ['LOW', 'NORMAL', 'HIGH', 'URGENT'] as const,
+  schema: 'crm',
+  description: 'Priority of a task.',
+});
+
+/**
+ * Task status enum.
+ */
+export const TaskStatusEnum = defineEntityEnum({
+  name: 'TaskStatus',
+  values: ['PENDING', 'IN_PROGRESS', 'COMPLETED', 'CANCELLED'] as const,
+  schema: 'crm',
+  description: 'Status of a task.',
+});
+
+/**
+ * Task entity - follow-up activities.
+ */
+export const TaskEntity = defineEntity({
+  name: 'Task',
+  description: 'A task or follow-up activity.',
+  schema: 'crm',
+  map: 'task',
+  fields: {
+    id: field.id(),
+    title: field.string({ description: 'Task title' }),
+    description: field.string({ isOptional: true }),
+
+    // Type and priority
+    type: field.enum('TaskType', { default: 'TODO' }),
+    priority: field.enum('TaskPriority', { default: 'NORMAL' }),
+    status: field.enum('TaskStatus', { default: 'PENDING' }),
+
+    // Schedule
+    dueDate: field.dateTime({ isOptional: true }),
+    reminderAt: field.dateTime({ isOptional: true }),
+
+    // Associations (polymorphic)
+    contactId: field.string({ isOptional: true }),
+    dealId: field.string({ isOptional: true }),
+    companyId: field.string({ isOptional: true }),
+
+    // Ownership
+    organizationId: field.foreignKey(),
+    assignedTo: field.foreignKey({ description: 'User assigned to this task' }),
+    createdBy: field.foreignKey(),
+
+    // Completion
+    completedAt: field.dateTime({ isOptional: true }),
+    completedBy: field.string({ isOptional: true }),
+
+    // Timestamps
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+
+    // Relations
+    contact: field.belongsTo('Contact', ['contactId'], ['id']),
+    deal: field.belongsTo('Deal', ['dealId'], ['id']),
+    company: field.belongsTo('Company', ['companyId'], ['id']),
+  },
+  indexes: [
+    index.on(['organizationId', 'assignedTo', 'status']),
+    index.on(['dueDate', 'status']),
+    index.on(['contactId']),
+    index.on(['dealId']),
+  ],
+  enums: [TaskTypeEnum, TaskPriorityEnum, TaskStatusEnum],
+});
+
+/**
+ * Activity entity - interaction history.
+ */
+export const ActivityEntity = defineEntity({
+  name: 'Activity',
+  description: 'An activity/interaction logged in the CRM.',
+  schema: 'crm',
+  map: 'activity',
+  fields: {
+    id: field.id(),
+    type: field.enum('TaskType'),
+    subject: field.string(),
+    description: field.string({ isOptional: true }),
+
+    // Associations
+    contactId: field.string({ isOptional: true }),
+    dealId: field.string({ isOptional: true }),
+    companyId: field.string({ isOptional: true }),
+
+    // Ownership
+    organizationId: field.foreignKey(),
+    performedBy: field.foreignKey(),
+
+    // Outcome
+    outcome: field.string({ isOptional: true }),
+
+    // Timing
+    occurredAt: field.dateTime(),
+    duration: field.int({
+      isOptional: true,
+      description: 'Duration in minutes',
+    }),
+
+    // Timestamps
+    createdAt: field.createdAt(),
+
+    // Relations
+    contact: field.belongsTo('Contact', ['contactId'], ['id']),
+    deal: field.belongsTo('Deal', ['dealId'], ['id']),
+    company: field.belongsTo('Company', ['companyId'], ['id']),
+  },
+  indexes: [
+    index.on(['contactId', 'occurredAt']),
+    index.on(['dealId', 'occurredAt']),
+  ],
+});

package/src/events.ts

@@ -0,0 +1,142 @@
+import { ScalarTypeEnum, defineSchemaModel } from '@lssm/lib.schema';
+import { defineEvent } from '@lssm/lib.contracts';
+
+// ============ Contact Event Payloads ============
+
+const ContactCreatedPayload = defineSchemaModel({
+  name: 'ContactCreatedPayload',
+  description: 'Payload when a contact is created',
+  fields: {
+    contactId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    email: { type: ScalarTypeEnum.EmailAddress(), isOptional: true },
+    organizationId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false,
+    },
+    ownerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+  },
+});
+
+// ============ Deal Event Payloads ============
+
+const DealCreatedPayload = defineSchemaModel({
+  name: 'DealCreatedPayload',
+  description: 'Payload when a deal is created',
+  fields: {
+    dealId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    value: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
+    pipelineId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    stageId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    ownerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+  },
+});
+
+const DealMovedPayload = defineSchemaModel({
+  name: 'DealMovedEventPayload',
+  description: 'Payload when a deal is moved to another stage',
+  fields: {
+    dealId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    fromStageId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    toStageId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    movedBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    movedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+  },
+});
+
+const DealWonPayload = defineSchemaModel({
+  name: 'DealWonEventPayload',
+  description: 'Payload when a deal is won',
+  fields: {
+    dealId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    value: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
+    currency: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    contactId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    companyId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    ownerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    wonAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+  },
+});
+
+const DealLostPayload = defineSchemaModel({
+  name: 'DealLostEventPayload',
+  description: 'Payload when a deal is lost',
+  fields: {
+    dealId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    value: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
+    reason: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    ownerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    lostAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+  },
+});
+
+// ============ Task Event Payloads ============
+
+const TaskCompletedPayload = defineSchemaModel({
+  name: 'TaskCompletedPayload',
+  description: 'Payload when a task is completed',
+  fields: {
+    taskId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    type: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    assignedTo: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    completedBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+  },
+});
+
+// ============ Events ============
+
+export const ContactCreatedEvent = defineEvent({
+  name: 'contact.created',
+  version: 1,
+  description: 'A new contact has been created.',
+  payload: ContactCreatedPayload,
+});
+
+export const DealCreatedEvent = defineEvent({
+  name: 'deal.created',
+  version: 1,
+  description: 'A new deal has been created.',
+  payload: DealCreatedPayload,
+});
+
+export const DealMovedEvent = defineEvent({
+  name: 'deal.moved',
+  version: 1,
+  description: 'A deal has been moved to a different stage.',
+  payload: DealMovedPayload,
+});
+
+export const DealWonEvent = defineEvent({
+  name: 'deal.won',
+  version: 1,
+  description: 'A deal has been won.',
+  payload: DealWonPayload,
+});
+
+export const DealLostEvent = defineEvent({
+  name: 'deal.lost',
+  version: 1,
+  description: 'A deal has been lost.',
+  payload: DealLostPayload,
+});
+
+export const TaskCompletedEvent = defineEvent({
+  name: 'task.completed',
+  version: 1,
+  description: 'A task has been completed.',
+  payload: TaskCompletedPayload,
+});
+
+// ============ All Events ============
+
+export const CrmPipelineEvents = {
+  ContactCreatedEvent,
+  DealCreatedEvent,
+  DealMovedEvent,
+  DealWonEvent,
+  DealLostEvent,
+  TaskCompletedEvent,
+};

package/src/feature.ts

@@ -0,0 +1,89 @@
+/**
+ * CRM Pipeline Feature Module Specification
+ *
+ * Defines the feature module for CRM and sales pipeline capabilities.
+ */
+import type { FeatureModuleSpec } from '@lssm/lib.contracts';
+
+/**
+ * CRM Pipeline feature module that bundles deal management,
+ * pipeline operations, and contact management into an installable feature.
+ */
+export const CrmPipelineFeature: FeatureModuleSpec = {
+  meta: {
+    key: 'crm-pipeline',
+    title: 'CRM Pipeline',
+    description:
+      'CRM and sales pipeline management with deals, contacts, and companies',
+    domain: 'crm',
+    owners: ['crm-team'],
+    tags: ['crm', 'sales', 'pipeline', 'deals'],
+    stability: 'experimental',
+  },
+
+  // All contract operations included in this feature
+  operations: [
+    // Deal operations
+    { name: 'crm.deal.create', version: 1 },
+    { name: 'crm.deal.move', version: 1 },
+    { name: 'crm.deal.win', version: 1 },
+    { name: 'crm.deal.lose', version: 1 },
+    { name: 'crm.deal.list', version: 1 },
+  ],
+
+  // Events emitted by this feature
+  events: [
+    // Deal events
+    { name: 'deal.created', version: 1 },
+    { name: 'deal.moved', version: 1 },
+    { name: 'deal.won', version: 1 },
+    { name: 'deal.lost', version: 1 },
+  ],
+
+  // Presentations associated with this feature
+  presentations: [
+    { name: 'crm.dashboard', version: 1 },
+    { name: 'crm.pipeline.kanban', version: 1 },
+    { name: 'crm.deal.list', version: 1 },
+    { name: 'crm.deal.detail', version: 1 },
+    { name: 'crm.deal.card', version: 1 },
+    { name: 'crm.pipeline.metrics', version: 1 },
+  ],
+
+  // Link operations to their primary presentations
+  opToPresentation: [
+    {
+      op: { name: 'crm.deal.list', version: 1 },
+      pres: { name: 'crm.pipeline.kanban', version: 1 },
+    },
+    {
+      op: { name: 'crm.deal.move', version: 1 },
+      pres: { name: 'crm.pipeline.kanban', version: 1 },
+    },
+  ],
+
+  // Target requirements for multi-surface rendering
+  presentationsTargets: [
+    { name: 'crm.dashboard', version: 1, targets: ['react', 'markdown'] },
+    { name: 'crm.pipeline.kanban', version: 1, targets: ['react', 'markdown'] },
+    {
+      name: 'crm.deal.list',
+      version: 1,
+      targets: ['react', 'markdown', 'application/json'],
+    },
+    {
+      name: 'crm.pipeline.metrics',
+      version: 1,
+      targets: ['react', 'markdown'],
+    },
+  ],
+
+  // Capability requirements
+  capabilities: {
+    requires: [
+      { key: 'identity', version: 1 },
+      { key: 'audit-trail', version: 1 },
+      { key: 'notifications', version: 1 },
+    ],
+  },
+};

package/src/handlers/deal.handlers.ts

@@ -0,0 +1,247 @@
+/**
+ * Mock handlers for Deal contracts
+ */
+import { MOCK_DEALS, MOCK_STAGES } from './mock-data';
+
+// Types inferred from contract schemas
+export interface Deal {
+  id: string;
+  name: string;
+  value: number;
+  currency: string;
+  pipelineId: string;
+  stageId: string;
+  status: 'OPEN' | 'WON' | 'LOST' | 'STALE';
+  contactId?: string;
+  companyId?: string;
+  ownerId: string;
+  expectedCloseDate?: Date;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface CreateDealInput {
+  name: string;
+  value: number;
+  currency?: string;
+  pipelineId: string;
+  stageId: string;
+  contactId?: string;
+  companyId?: string;
+  expectedCloseDate?: Date;
+}
+
+export interface MoveDealInput {
+  dealId: string;
+  stageId: string;
+  position?: number;
+}
+
+export interface WinDealInput {
+  dealId: string;
+  wonSource?: string;
+  notes?: string;
+}
+
+export interface LoseDealInput {
+  dealId: string;
+  lostReason: string;
+  notes?: string;
+}
+
+export interface ListDealsInput {
+  pipelineId?: string;
+  stageId?: string;
+  status?: 'OPEN' | 'WON' | 'LOST' | 'all';
+  ownerId?: string;
+  search?: string;
+  limit?: number;
+  offset?: number;
+}
+
+export interface ListDealsOutput {
+  deals: Deal[];
+  total: number;
+  totalValue: number;
+}
+
+/**
+ * Mock handler for ListDealsContract
+ */
+export async function mockListDealsHandler(
+  input: ListDealsInput
+): Promise<ListDealsOutput> {
+  const {
+    pipelineId,
+    stageId,
+    status,
+    ownerId,
+    search,
+    limit = 20,
+    offset = 0,
+  } = input;
+
+  let filtered = [...MOCK_DEALS];
+
+  if (pipelineId) {
+    filtered = filtered.filter((d) => d.pipelineId === pipelineId);
+  }
+
+  if (stageId) {
+    filtered = filtered.filter((d) => d.stageId === stageId);
+  }
+
+  if (status && status !== 'all') {
+    filtered = filtered.filter((d) => d.status === status);
+  }
+
+  if (ownerId) {
+    filtered = filtered.filter((d) => d.ownerId === ownerId);
+  }
+
+  if (search) {
+    const q = search.toLowerCase();
+    filtered = filtered.filter((d) => d.name.toLowerCase().includes(q));
+  }
+
+  // Sort by value descending
+  filtered.sort((a, b) => b.value - a.value);
+
+  const total = filtered.length;
+  const totalValue = filtered.reduce((sum, d) => sum + d.value, 0);
+  const deals = filtered.slice(offset, offset + limit);
+
+  return {
+    deals,
+    total,
+    totalValue,
+  };
+}
+
+/**
+ * Mock handler for CreateDealContract
+ */
+export async function mockCreateDealHandler(
+  input: CreateDealInput,
+  context: { ownerId: string }
+): Promise<Deal> {
+  const now = new Date();
+
+  const deal: Deal = {
+    id: `deal-${Date.now()}`,
+    name: input.name,
+    value: input.value,
+    currency: input.currency ?? 'USD',
+    pipelineId: input.pipelineId,
+    stageId: input.stageId,
+    status: 'OPEN',
+    contactId: input.contactId,
+    companyId: input.companyId,
+    ownerId: context.ownerId,
+    expectedCloseDate: input.expectedCloseDate,
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  MOCK_DEALS.push(deal);
+
+  return deal;
+}
+
+/**
+ * Mock handler for MoveDealContract
+ */
+export async function mockMoveDealHandler(input: MoveDealInput): Promise<Deal> {
+  const dealIndex = MOCK_DEALS.findIndex((d) => d.id === input.dealId);
+  if (dealIndex === -1) {
+    throw new Error('NOT_FOUND');
+  }
+  const deal = MOCK_DEALS[dealIndex]!;
+
+  const stage = MOCK_STAGES.find((s) => s.id === input.stageId);
+  if (!stage) {
+    throw new Error('INVALID_STAGE');
+  }
+
+  const updatedDeal: Deal = {
+    ...deal,
+    stageId: input.stageId,
+    updatedAt: new Date(),
+  };
+
+  MOCK_DEALS[dealIndex] = updatedDeal;
+
+  return updatedDeal;
+}
+
+/**
+ * Mock handler for WinDealContract
+ */
+export async function mockWinDealHandler(input: WinDealInput): Promise<Deal> {
+  const dealIndex = MOCK_DEALS.findIndex((d) => d.id === input.dealId);
+  if (dealIndex === -1) {
+    throw new Error('NOT_FOUND');
+  }
+  const deal = MOCK_DEALS[dealIndex]!;
+  if (!deal) {
+    throw new Error('NOT_FOUND');
+  }
+
+  const updatedDeal: Deal = {
+    ...deal,
+    status: 'WON' as const,
+    updatedAt: new Date(),
+  };
+
+  MOCK_DEALS[dealIndex] = updatedDeal;
+
+  return updatedDeal;
+}
+
+/**
+ * Mock handler for LoseDealContract
+ */
+export async function mockLoseDealHandler(input: LoseDealInput): Promise<Deal> {
+  const dealIndex = MOCK_DEALS.findIndex((d) => d.id === input.dealId);
+  if (dealIndex === -1) {
+    throw new Error('NOT_FOUND');
+  }
+  const deal = MOCK_DEALS[dealIndex]!;
+
+  const updatedDeal: Deal = {
+    ...deal,
+    status: 'LOST' as const,
+    updatedAt: new Date(),
+  };
+
+  MOCK_DEALS[dealIndex] = updatedDeal;
+
+  return updatedDeal;
+}
+
+/**
+ * Get deals grouped by stage for Kanban view
+ */
+export async function mockGetDealsByStageHandler(input: {
+  pipelineId: string;
+}): Promise<Record<string, Deal[]>> {
+  const deals = MOCK_DEALS.filter(
+    (d) => d.pipelineId === input.pipelineId && d.status === 'OPEN'
+  );
+
+  const grouped: Record<string, Deal[]> = {};
+  for (const stage of MOCK_STAGES) {
+    grouped[stage.id] = deals.filter((d) => d.stageId === stage.id);
+  }
+
+  return grouped;
+}
+
+/**
+ * Get pipeline stages
+ */
+export async function mockGetPipelineStagesHandler(input: {
+  pipelineId: string;
+}) {
+  return MOCK_STAGES.filter((s) => s.pipelineId === input.pipelineId);
+}

package/src/handlers/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Mock handlers for crm-pipeline example
+ *
+ * These handlers provide mock implementations of all contracts
+ * for use in demos, tests, and the sandbox environment.
+ */
+
+// Mock data
+export * from './mock-data';
+
+// Deal handlers
+export {
+  mockListDealsHandler,
+  mockCreateDealHandler,
+  mockMoveDealHandler,
+  mockWinDealHandler,
+  mockLoseDealHandler,
+  mockGetDealsByStageHandler,
+  mockGetPipelineStagesHandler,
+  type Deal,
+  type CreateDealInput,
+  type MoveDealInput,
+  type WinDealInput,
+  type LoseDealInput,
+  type ListDealsInput,
+  type ListDealsOutput,
+} from './deal.handlers';