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

package/src/contracts/deal.ts

@@ -0,0 +1,308 @@
+import { defineCommand, defineQuery } from '@lssm/lib.contracts/spec';
+import {
+  defineSchemaModel,
+  ScalarTypeEnum,
+  defineEnum,
+} from '@lssm/lib.schema';
+
+const OWNERS = ['example.crm-pipeline'] as const;
+
+// ============ Enums ============
+
+const DealStatusSchemaEnum = defineEnum('DealStatus', [
+  'OPEN',
+  'WON',
+  'LOST',
+  'STALE',
+]);
+export const DealStatusFilterEnum = defineEnum('DealStatusFilter', [
+  'OPEN',
+  'WON',
+  'LOST',
+  'all',
+]);
+
+// ============ Schemas ============
+
+export const DealModel = defineSchemaModel({
+  name: 'Deal',
+  description: 'A deal in the CRM pipeline',
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    value: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
+    currency: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    pipelineId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    stageId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    status: { type: DealStatusSchemaEnum, isOptional: false },
+    contactId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    companyId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    ownerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    expectedCloseDate: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    updatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+  },
+});
+
+export const CreateDealInputModel = defineSchemaModel({
+  name: 'CreateDealInput',
+  description: 'Input for creating a deal',
+  fields: {
+    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    value: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
+    currency: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    pipelineId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    stageId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    contactId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    companyId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    expectedCloseDate: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+  },
+});
+
+export const MoveDealInputModel = defineSchemaModel({
+  name: 'MoveDealInput',
+  description: 'Input for moving a deal to another stage',
+  fields: {
+    dealId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    stageId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    position: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+  },
+});
+
+export const DealMovedPayloadModel = defineSchemaModel({
+  name: 'DealMovedPayload',
+  fields: {
+    dealId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    fromStage: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    toStage: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+  },
+});
+
+export const WinDealInputModel = defineSchemaModel({
+  name: 'WinDealInput',
+  description: 'Input for marking a deal as won',
+  fields: {
+    dealId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    wonSource: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    notes: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+  },
+});
+
+export const DealWonPayloadModel = defineSchemaModel({
+  name: 'DealWonPayload',
+  fields: {
+    dealId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    value: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
+  },
+});
+
+export const LoseDealInputModel = defineSchemaModel({
+  name: 'LoseDealInput',
+  description: 'Input for marking a deal as lost',
+  fields: {
+    dealId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    lostReason: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    notes: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+  },
+});
+
+export const DealLostPayloadModel = defineSchemaModel({
+  name: 'DealLostPayload',
+  fields: {
+    dealId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    reason: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+  },
+});
+
+export const ListDealsInputModel = defineSchemaModel({
+  name: 'ListDealsInput',
+  description: 'Input for listing deals',
+  fields: {
+    pipelineId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    stageId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    status: { type: DealStatusFilterEnum, isOptional: true },
+    ownerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    search: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    limit: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: true,
+      defaultValue: 20,
+    },
+    offset: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: true,
+      defaultValue: 0,
+    },
+  },
+});
+
+export const ListDealsOutputModel = defineSchemaModel({
+  name: 'ListDealsOutput',
+  description: 'Output for listing deals',
+  fields: {
+    deals: { type: DealModel, isArray: true, isOptional: false },
+    total: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    totalValue: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
+  },
+});
+
+// ============ Contracts ============
+
+/**
+ * Create a new deal.
+ */
+export const CreateDealContract = defineCommand({
+  meta: {
+    name: 'crm.deal.create',
+    version: 1,
+    stability: 'stable',
+    owners: [...OWNERS],
+    tags: ['crm', 'deal', 'create'],
+    description: 'Create a new deal in the pipeline.',
+    goal: 'Allow sales reps to create new opportunities.',
+    context: 'Deal creation UI, quick add.',
+  },
+  io: {
+    input: CreateDealInputModel,
+    output: DealModel,
+  },
+  policy: {
+    auth: 'user',
+  },
+  sideEffects: {
+    emits: [
+      {
+        name: 'deal.created',
+        version: 1,
+        when: 'Deal is created',
+        payload: DealModel,
+      },
+    ],
+    audit: ['deal.created'],
+  },
+});
+
+/**
+ * Move deal to a different stage.
+ */
+export const MoveDealContract = defineCommand({
+  meta: {
+    name: 'crm.deal.move',
+    version: 1,
+    stability: 'stable',
+    owners: [...OWNERS],
+    tags: ['crm', 'deal', 'move', 'kanban'],
+    description: 'Move a deal to a different stage.',
+    goal: 'Allow drag-and-drop stage movement in Kanban.',
+    context: 'Pipeline Kanban view.',
+  },
+  io: {
+    input: MoveDealInputModel,
+    output: DealModel,
+  },
+  policy: {
+    auth: 'user',
+  },
+  sideEffects: {
+    emits: [
+      {
+        name: 'deal.moved',
+        version: 1,
+        when: 'Deal stage changed',
+        payload: DealMovedPayloadModel,
+      },
+    ],
+    audit: ['deal.moved'],
+  },
+});
+
+/**
+ * Mark deal as won.
+ */
+export const WinDealContract = defineCommand({
+  meta: {
+    name: 'crm.deal.win',
+    version: 1,
+    stability: 'stable',
+    owners: [...OWNERS],
+    tags: ['crm', 'deal', 'won'],
+    description: 'Mark a deal as won.',
+    goal: 'Close a deal as successful.',
+    context: 'Deal closing flow.',
+  },
+  io: {
+    input: WinDealInputModel,
+    output: DealModel,
+  },
+  policy: {
+    auth: 'user',
+  },
+  sideEffects: {
+    emits: [
+      {
+        name: 'deal.won',
+        version: 1,
+        when: 'Deal is won',
+        payload: DealWonPayloadModel,
+      },
+    ],
+    audit: ['deal.won'],
+  },
+});
+
+/**
+ * Mark deal as lost.
+ */
+export const LoseDealContract = defineCommand({
+  meta: {
+    name: 'crm.deal.lose',
+    version: 1,
+    stability: 'stable',
+    owners: [...OWNERS],
+    tags: ['crm', 'deal', 'lost'],
+    description: 'Mark a deal as lost.',
+    goal: 'Close a deal as unsuccessful.',
+    context: 'Deal closing flow.',
+  },
+  io: {
+    input: LoseDealInputModel,
+    output: DealModel,
+  },
+  policy: {
+    auth: 'user',
+  },
+  sideEffects: {
+    emits: [
+      {
+        name: 'deal.lost',
+        version: 1,
+        when: 'Deal is lost',
+        payload: DealLostPayloadModel,
+      },
+    ],
+    audit: ['deal.lost'],
+  },
+});
+
+/**
+ * List deals in pipeline.
+ */
+export const ListDealsContract = defineQuery({
+  meta: {
+    name: 'crm.deal.list',
+    version: 1,
+    stability: 'stable',
+    owners: [...OWNERS],
+    tags: ['crm', 'deal', 'list'],
+    description: 'List deals with filters.',
+    goal: 'Show pipeline, deal lists, dashboards.',
+    context: 'Pipeline view, deal list.',
+  },
+  io: {
+    input: ListDealsInputModel,
+    output: ListDealsOutputModel,
+  },
+  policy: {
+    auth: 'user',
+  },
+});

package/src/contracts/index.ts

@@ -0,0 +1,19 @@
+// Deal contracts and models
+export {
+  DealStatusFilterEnum,
+  DealModel,
+  CreateDealInputModel,
+  MoveDealInputModel,
+  DealMovedPayloadModel,
+  WinDealInputModel,
+  DealWonPayloadModel,
+  LoseDealInputModel,
+  DealLostPayloadModel,
+  ListDealsInputModel,
+  ListDealsOutputModel,
+  CreateDealContract,
+  MoveDealContract,
+  WinDealContract,
+  LoseDealContract,
+  ListDealsContract,
+} from './deal';

package/src/entities/company.ts

@@ -0,0 +1,72 @@
+import { defineEntity, defineEntityEnum, field, index } from '@lssm/lib.schema';
+
+/**
+ * Company size enum.
+ */
+export const CompanySizeEnum = defineEntityEnum({
+  name: 'CompanySize',
+  values: ['STARTUP', 'SMALL', 'MEDIUM', 'LARGE', 'ENTERPRISE'] as const,
+  schema: 'crm',
+  description: 'Size category of a company.',
+});
+
+/**
+ * Company entity - organization/account.
+ */
+export const CompanyEntity = defineEntity({
+  name: 'Company',
+  description: 'A company/organization in the CRM.',
+  schema: 'crm',
+  map: 'company',
+  fields: {
+    id: field.id({ description: 'Unique company ID' }),
+
+    // Basic info
+    name: field.string({ description: 'Company name' }),
+    domain: field.string({ isOptional: true, description: 'Website domain' }),
+    website: field.url({ isOptional: true }),
+
+    // Industry
+    industry: field.string({ isOptional: true }),
+
+    // Size
+    size: field.enum('CompanySize', { isOptional: true }),
+    employeeCount: field.int({ isOptional: true }),
+    annualRevenue: field.decimal({ isOptional: true }),
+
+    // Ownership
+    organizationId: field.foreignKey(),
+    ownerId: field.foreignKey({ description: 'Account owner' }),
+
+    // Contact info
+    phone: field.string({ isOptional: true }),
+    email: field.email({ 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 }),
+
+    // Social
+    linkedInUrl: field.url({ isOptional: true }),
+
+    // Notes
+    description: field.string({ isOptional: true }),
+    tags: field.string({ isArray: true }),
+
+    // Custom fields
+    customFields: field.json({ isOptional: true }),
+
+    // Timestamps
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+
+    // Relations
+    contacts: field.hasMany('Contact'),
+    deals: field.hasMany('Deal'),
+  },
+  indexes: [index.on(['organizationId', 'ownerId']), index.on(['domain'])],
+  enums: [CompanySizeEnum],
+});

package/src/entities/contact.ts

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

@@ -0,0 +1,155 @@
+import { defineEntity, defineEntityEnum, field, index } from '@lssm/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,63 @@
+// Contact entities
+export { ContactStatusEnum, ContactEntity } from './contact';
+
+// Company entities
+export { CompanySizeEnum, CompanyEntity } from './company';
+
+// Deal entities
+export {
+  DealStatusEnum,
+  PipelineEntity,
+  StageEntity,
+  DealEntity,
+} from './deal';
+
+// Task entities
+export {
+  TaskTypeEnum,
+  TaskPriorityEnum,
+  TaskStatusEnum,
+  TaskEntity,
+  ActivityEntity,
+} from './task';
+
+// Schema contribution
+import { ContactEntity, ContactStatusEnum } from './contact';
+import { CompanyEntity, CompanySizeEnum } from './company';
+import {
+  PipelineEntity,
+  StageEntity,
+  DealEntity,
+  DealStatusEnum,
+} from './deal';
+import {
+  TaskEntity,
+  ActivityEntity,
+  TaskTypeEnum,
+  TaskPriorityEnum,
+  TaskStatusEnum,
+} from './task';
+import type { ModuleSchemaContribution } from '@lssm/lib.schema';
+
+export const crmPipelineEntities = [
+  ContactEntity,
+  CompanyEntity,
+  PipelineEntity,
+  StageEntity,
+  DealEntity,
+  TaskEntity,
+  ActivityEntity,
+];
+
+export const crmPipelineSchemaContribution: ModuleSchemaContribution = {
+  moduleId: '@lssm/example.crm-pipeline',
+  entities: crmPipelineEntities,
+  enums: [
+    ContactStatusEnum,
+    CompanySizeEnum,
+    DealStatusEnum,
+    TaskTypeEnum,
+    TaskPriorityEnum,
+    TaskStatusEnum,
+  ],
+};