@contractspec/example.crm-pipeline 0.0.0-canary-20260113170453

package/src/entities/contact.entity.ts

@@ -0,0 +1,93 @@
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index,
+} from '@contractspec/lib.schema';
+
+/**
+ * Contact status enum.
+ */
+export const ContactStatusEnum = defineEntityEnum({
+  name: 'ContactStatus',
+  values: ['LEAD', 'PROSPECT', 'CUSTOMER', 'CHURNED', 'ARCHIVED'] as const,
+  schema: 'crm',
+  description: 'Status of a contact in the sales funnel.',
+});
+
+/**
+ * Contact entity - individual person.
+ */
+export const ContactEntity = defineEntity({
+  name: 'Contact',
+  description: 'An individual person in the CRM.',
+  schema: 'crm',
+  map: 'contact',
+  fields: {
+    id: field.id({ description: 'Unique contact ID' }),
+
+    // Basic info
+    firstName: field.string({ description: 'First name' }),
+    lastName: field.string({ description: 'Last name' }),
+    email: field.email({ isOptional: true, isUnique: true }),
+    phone: field.string({ isOptional: true }),
+
+    // Company
+    companyId: field.string({
+      isOptional: true,
+      description: 'Associated company',
+    }),
+    jobTitle: field.string({ isOptional: true }),
+
+    // Status
+    status: field.enum('ContactStatus', { default: 'LEAD' }),
+
+    // Ownership
+    organizationId: field.foreignKey(),
+    ownerId: field.foreignKey({
+      description: 'Sales rep who owns this contact',
+    }),
+
+    // Source
+    source: field.string({ isOptional: true, description: 'Lead source' }),
+
+    // Social
+    linkedInUrl: field.url({ isOptional: true }),
+    twitterHandle: field.string({ isOptional: true }),
+
+    // Address
+    address: field.string({ isOptional: true }),
+    city: field.string({ isOptional: true }),
+    state: field.string({ isOptional: true }),
+    country: field.string({ isOptional: true }),
+    postalCode: field.string({ isOptional: true }),
+
+    // Notes
+    notes: field.string({ isOptional: true }),
+    tags: field.string({ isArray: true }),
+
+    // Custom fields
+    customFields: field.json({ isOptional: true }),
+
+    // Engagement
+    lastContactedAt: field.dateTime({ isOptional: true }),
+    nextFollowUpAt: field.dateTime({ isOptional: true }),
+
+    // Timestamps
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+
+    // Relations
+    company: field.belongsTo('Company', ['companyId'], ['id']),
+    deals: field.hasMany('Deal'),
+    tasks: field.hasMany('Task'),
+    activities: field.hasMany('Activity'),
+  },
+  indexes: [
+    index.on(['organizationId', 'status']),
+    index.on(['organizationId', 'ownerId']),
+    index.on(['organizationId', 'companyId']),
+    index.on(['email']),
+  ],
+  enums: [ContactStatusEnum],
+});

package/src/entities/deal.entity.ts

@@ -0,0 +1,160 @@
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index,
+} from '@contractspec/lib.schema';
+
+/**
+ * Deal status enum.
+ */
+export const DealStatusEnum = defineEntityEnum({
+  name: 'DealStatus',
+  values: ['OPEN', 'WON', 'LOST', 'STALE'] as const,
+  schema: 'crm',
+  description: 'Status of a deal.',
+});
+
+/**
+ * Pipeline entity - sales pipeline definition.
+ */
+export const PipelineEntity = defineEntity({
+  name: 'Pipeline',
+  description: 'A sales pipeline with stages.',
+  schema: 'crm',
+  map: 'pipeline',
+  fields: {
+    id: field.id(),
+    name: field.string({ description: 'Pipeline name' }),
+    description: field.string({ isOptional: true }),
+
+    // Ownership
+    organizationId: field.foreignKey(),
+
+    // Settings
+    isDefault: field.boolean({ default: false }),
+
+    // Timestamps
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+
+    // Relations
+    stages: field.hasMany('Stage'),
+    deals: field.hasMany('Deal'),
+  },
+});
+
+/**
+ * Stage entity - pipeline stage.
+ */
+export const StageEntity = defineEntity({
+  name: 'Stage',
+  description: 'A stage within a sales pipeline.',
+  schema: 'crm',
+  map: 'stage',
+  fields: {
+    id: field.id(),
+    name: field.string({ description: 'Stage name' }),
+    pipelineId: field.foreignKey(),
+
+    // Position
+    position: field.int({ description: 'Order in pipeline' }),
+
+    // Probability
+    probability: field.int({
+      default: 0,
+      description: 'Win probability (0-100)',
+    }),
+
+    // Type
+    isWonStage: field.boolean({ default: false }),
+    isLostStage: field.boolean({ default: false }),
+
+    // Settings
+    color: field.string({
+      isOptional: true,
+      description: 'Stage color for UI',
+    }),
+
+    // Timestamps
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+
+    // Relations
+    pipeline: field.belongsTo('Pipeline', ['pipelineId'], ['id'], {
+      onDelete: 'Cascade',
+    }),
+    deals: field.hasMany('Deal'),
+  },
+  indexes: [index.on(['pipelineId', 'position'])],
+});
+
+/**
+ * Deal entity - sales opportunity.
+ */
+export const DealEntity = defineEntity({
+  name: 'Deal',
+  description: 'A sales opportunity/deal.',
+  schema: 'crm',
+  map: 'deal',
+  fields: {
+    id: field.id({ description: 'Unique deal ID' }),
+    name: field.string({ description: 'Deal name' }),
+
+    // Value
+    value: field.decimal({ description: 'Deal value' }),
+    currency: field.string({ default: '"USD"' }),
+
+    // Pipeline
+    pipelineId: field.foreignKey(),
+    stageId: field.foreignKey(),
+
+    // Status
+    status: field.enum('DealStatus', { default: 'OPEN' }),
+
+    // Associations
+    contactId: field.string({ isOptional: true }),
+    companyId: field.string({ isOptional: true }),
+
+    // Ownership
+    organizationId: field.foreignKey(),
+    ownerId: field.foreignKey({ description: 'Deal owner' }),
+
+    // Timeline
+    expectedCloseDate: field.dateTime({ isOptional: true }),
+    closedAt: field.dateTime({ isOptional: true }),
+
+    // Tracking
+    lostReason: field.string({ isOptional: true }),
+    wonSource: field.string({ isOptional: true }),
+
+    // Notes
+    notes: field.string({ isOptional: true }),
+    tags: field.string({ isArray: true }),
+
+    // Custom fields
+    customFields: field.json({ isOptional: true }),
+
+    // Position in stage (for Kanban)
+    stagePosition: field.int({ default: 0 }),
+
+    // Timestamps
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+
+    // Relations
+    pipeline: field.belongsTo('Pipeline', ['pipelineId'], ['id']),
+    stage: field.belongsTo('Stage', ['stageId'], ['id']),
+    contact: field.belongsTo('Contact', ['contactId'], ['id']),
+    company: field.belongsTo('Company', ['companyId'], ['id']),
+    tasks: field.hasMany('Task'),
+    activities: field.hasMany('Activity'),
+  },
+  indexes: [
+    index.on(['organizationId', 'status']),
+    index.on(['pipelineId', 'stageId', 'stagePosition']),
+    index.on(['ownerId', 'status']),
+    index.on(['expectedCloseDate']),
+  ],
+  enums: [DealStatusEnum],
+});

package/src/entities/index.ts

@@ -0,0 +1,45 @@
+export * from './company.entity';
+export * from './contact.entity';
+export * from './deal.entity';
+export * from './task.entity';
+
+import type { ModuleSchemaContribution } from '@contractspec/lib.schema';
+import { CompanyEntity, CompanySizeEnum } from './company.entity';
+import { ContactEntity, ContactStatusEnum } from './contact.entity';
+import {
+  DealEntity,
+  PipelineEntity,
+  StageEntity,
+  DealStatusEnum,
+} from './deal.entity';
+import {
+  TaskEntity,
+  ActivityEntity,
+  TaskTypeEnum,
+  TaskPriorityEnum,
+  TaskStatusEnum,
+} from './task.entity';
+
+/**
+ * CRM Pipeline schema contribution.
+ */
+export const crmPipelineSchemaContribution: ModuleSchemaContribution = {
+  moduleId: '@contractspec/example.crm-pipeline',
+  entities: [
+    CompanyEntity,
+    ContactEntity,
+    DealEntity,
+    PipelineEntity,
+    StageEntity,
+    TaskEntity,
+    ActivityEntity,
+  ],
+  enums: [
+    CompanySizeEnum,
+    ContactStatusEnum,
+    DealStatusEnum,
+    TaskTypeEnum,
+    TaskPriorityEnum,
+    TaskStatusEnum,
+  ],
+};

package/src/entities/task.entity.ts

@@ -0,0 +1,137 @@
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index,
+} from '@contractspec/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/contact.event.ts

@@ -0,0 +1,31 @@
+import { ScalarTypeEnum, defineSchemaModel } from '@contractspec/lib.schema';
+import { defineEvent } from '@contractspec/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 },
+  },
+});
+
+export const ContactCreatedEvent = defineEvent({
+  meta: {
+    key: 'contact.created',
+    version: '1.0.0',
+    description: 'A new contact has been created.',
+    stability: 'stable',
+    owners: ['@crm-team'],
+    tags: ['contact', 'created'],
+  },
+  payload: ContactCreatedPayload,
+});

package/src/events/deal.event.ts

@@ -0,0 +1,104 @@
+import { ScalarTypeEnum, defineSchemaModel } from '@contractspec/lib.schema';
+import { defineEvent } from '@contractspec/lib.contracts';
+
+// ============ 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 },
+  },
+});
+
+export const DealCreatedEvent = defineEvent({
+  meta: {
+    key: 'deal.created',
+    version: '1.0.0',
+    description: 'A new deal has been created.',
+    stability: 'stable',
+    owners: ['@crm-team'],
+    tags: ['deal', 'created'],
+  },
+  payload: DealCreatedPayload,
+});
+
+export const DealMovedEvent = defineEvent({
+  meta: {
+    key: 'deal.moved',
+    version: '1.0.0',
+    description: 'A deal has been moved to a different stage.',
+    stability: 'stable',
+    owners: ['@crm-team'],
+    tags: ['deal', 'moved'],
+  },
+  payload: DealMovedPayload,
+});
+
+export const DealWonEvent = defineEvent({
+  meta: {
+    key: 'deal.won',
+    version: '1.0.0',
+    description: 'A deal has been won.',
+    stability: 'stable',
+    owners: ['@crm-team'],
+    tags: ['deal', 'won'],
+  },
+  payload: DealWonPayload,
+});
+
+export const DealLostEvent = defineEvent({
+  meta: {
+    key: 'deal.lost',
+    version: '1.0.0',
+    description: 'A deal has been lost.',
+    stability: 'stable',
+    owners: ['@crm-team'],
+    tags: ['deal', 'lost'],
+  },
+  payload: DealLostPayload,
+});

package/src/events/index.ts

@@ -0,0 +1,3 @@
+export * from './contact.event';
+export * from './deal.event';
+export * from './task.event';

package/src/events/task.event.ts

@@ -0,0 +1,28 @@
+import { ScalarTypeEnum, defineSchemaModel } from '@contractspec/lib.schema';
+import { defineEvent } from '@contractspec/lib.contracts';
+
+// ============ 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 },
+  },
+});
+
+export const TaskCompletedEvent = defineEvent({
+  meta: {
+    key: 'task.completed',
+    version: '1.0.0',
+    description: 'A task has been completed.',
+    stability: 'stable',
+    owners: ['@crm-team'],
+    tags: ['task', 'lifecycle'],
+  },
+  payload: TaskCompletedPayload,
+});

package/src/example.ts

@@ -0,0 +1,38 @@
+import { defineExample } from '@contractspec/lib.contracts';
+
+const example = defineExample({
+  meta: {
+    key: 'crm-pipeline',
+    version: '1.0.0',
+    title: 'CRM Pipeline',
+    description:
+      'Sales CRM with contacts, companies, deals, pipelines, and tasks.',
+    kind: 'template',
+    visibility: 'public',
+    stability: 'experimental',
+    owners: ['@platform.core'],
+    tags: ['crm', 'sales', 'pipeline', 'deals'],
+  },
+  docs: {
+    rootDocId: 'docs.examples.crm-pipeline',
+  },
+  entrypoints: {
+    packageName: '@contractspec/example.crm-pipeline',
+    feature: './feature',
+    contracts: './contracts',
+    presentations: './presentations',
+    handlers: './handlers',
+    docs: './docs',
+  },
+  surfaces: {
+    templates: true,
+    sandbox: {
+      enabled: true,
+      modes: ['playground', 'specs', 'builder', 'markdown', 'evolution'],
+    },
+    studio: { enabled: true, installable: true },
+    mcp: { enabled: true },
+  },
+});
+
+export default example;