@contractspec/example.saas-boilerplate 0.0.0-canary-20260113170453

package/src/project/index.ts

@@ -0,0 +1,66 @@
+/**
+ * Project domain - project management within organizations.
+ */
+
+// Enums
+export {
+  ProjectStatusSchemaEnum,
+  ProjectStatusFilterEnum,
+} from './project.enum';
+
+// Schema models
+export {
+  ProjectModel,
+  CreateProjectInputModel,
+  UpdateProjectInputModel,
+  GetProjectInputModel,
+  DeleteProjectInputModel,
+  DeleteProjectOutputModel,
+  ProjectDeletedPayloadModel,
+  ListProjectsInputModel,
+  ListProjectsOutputModel,
+} from './project.schema';
+
+// Contracts
+export {
+  CreateProjectContract,
+  GetProjectContract,
+  UpdateProjectContract,
+  DeleteProjectContract,
+  ListProjectsContract,
+} from './project.operations';
+
+// Events
+export {
+  ProjectCreatedEvent,
+  ProjectUpdatedEvent,
+  ProjectDeletedEvent,
+  ProjectArchivedEvent,
+} from './project.event';
+
+// Entities
+export {
+  ProjectStatusEnum,
+  ProjectEntity,
+  ProjectMemberEntity,
+} from './project.entity';
+
+// Presentations
+export {
+  ProjectListPresentation,
+  ProjectDetailPresentation,
+} from './project.presentation';
+
+// Handlers
+export {
+  mockListProjectsHandler,
+  mockGetProjectHandler,
+  mockCreateProjectHandler,
+  mockUpdateProjectHandler,
+  mockDeleteProjectHandler,
+  type Project,
+  type CreateProjectInput,
+  type UpdateProjectInput,
+  type ListProjectsInput,
+  type ListProjectsOutput,
+} from './project.handler';

package/src/project/project.entity.ts

@@ -0,0 +1,93 @@
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index,
+} from '@contractspec/lib.schema';
+
+/**
+ * Project status enum for entities.
+ */
+export const ProjectStatusEnum = defineEntityEnum({
+  name: 'ProjectStatus',
+  values: ['DRAFT', 'ACTIVE', 'ARCHIVED', 'DELETED'] as const,
+  schema: 'saas_app',
+  description: 'Status of a project.',
+});
+
+/**
+ * Project entity - team-scoped work container.
+ */
+export const ProjectEntity = defineEntity({
+  name: 'Project',
+  description: 'A project belonging to an organization.',
+  schema: 'saas_app',
+  map: 'project',
+  fields: {
+    id: field.id({ description: 'Unique project ID' }),
+    name: field.string({ description: 'Project name' }),
+    description: field.string({
+      isOptional: true,
+      description: 'Project description',
+    }),
+    slug: field.string({
+      isOptional: true,
+      description: 'URL-friendly identifier',
+    }),
+
+    // Ownership
+    organizationId: field.foreignKey({ description: 'Owning organization' }),
+    createdBy: field.foreignKey({
+      description: 'User who created the project',
+    }),
+
+    // Status
+    status: field.enum('ProjectStatus', { default: 'DRAFT' }),
+
+    // Settings
+    isPublic: field.boolean({
+      default: false,
+      description: 'Whether project is publicly visible',
+    }),
+    settings: field.json({
+      isOptional: true,
+      description: 'Project-specific settings',
+    }),
+
+    // Metadata
+    tags: field.string({ isArray: true, description: 'Project tags' }),
+    metadata: field.json({ isOptional: true }),
+
+    // Timestamps
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    archivedAt: field.dateTime({ isOptional: true }),
+  },
+  indexes: [
+    index.on(['organizationId', 'status']),
+    index.on(['organizationId', 'createdAt']),
+    index.unique(['organizationId', 'slug']),
+  ],
+  enums: [ProjectStatusEnum],
+});
+
+/**
+ * ProjectMember entity - project-level access.
+ */
+export const ProjectMemberEntity = defineEntity({
+  name: 'ProjectMember',
+  description: 'User access to a specific project.',
+  schema: 'saas_app',
+  map: 'project_member',
+  fields: {
+    id: field.id(),
+    projectId: field.foreignKey(),
+    userId: field.foreignKey(),
+    role: field.string({
+      description: 'Role in project (owner, editor, viewer)',
+    }),
+    addedBy: field.string({ isOptional: true }),
+    createdAt: field.createdAt(),
+  },
+  indexes: [index.unique(['projectId', 'userId'])],
+});

package/src/project/project.enum.ts

@@ -0,0 +1,22 @@
+import { defineEnum } from '@contractspec/lib.schema';
+
+/**
+ * Project status enum for contract schemas.
+ * Note: Entity enum is defined separately in project.entity.ts
+ */
+export const ProjectStatusSchemaEnum = defineEnum('ProjectStatus', [
+  'DRAFT',
+  'ACTIVE',
+  'ARCHIVED',
+  'DELETED',
+]);
+
+/**
+ * Project status filter enum (includes 'all' option).
+ */
+export const ProjectStatusFilterEnum = defineEnum('ProjectStatusFilter', [
+  'DRAFT',
+  'ACTIVE',
+  'ARCHIVED',
+  'all',
+]);

package/src/project/project.event.ts

@@ -0,0 +1,128 @@
+import { ScalarTypeEnum, defineSchemaModel } from '@contractspec/lib.schema';
+import { defineEvent } from '@contractspec/lib.contracts';
+
+/**
+ * Payload when a project is created.
+ */
+const ProjectCreatedPayload = defineSchemaModel({
+  name: 'ProjectCreatedPayload',
+  description: 'Payload when a project is created',
+  fields: {
+    projectId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false,
+    },
+    createdBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+  },
+});
+
+/**
+ * Payload when a project is updated.
+ */
+const ProjectUpdatedPayload = defineSchemaModel({
+  name: 'ProjectUpdatedPayload',
+  description: 'Payload when a project is updated',
+  fields: {
+    projectId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    updatedFields: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isArray: true,
+      isOptional: false,
+    },
+    updatedBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    updatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+  },
+});
+
+/**
+ * Payload when a project is deleted.
+ */
+const ProjectDeletedPayload = defineSchemaModel({
+  name: 'ProjectDeletedPayload',
+  description: 'Payload when a project is deleted',
+  fields: {
+    projectId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false,
+    },
+    deletedBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    deletedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+  },
+});
+
+/**
+ * Payload when a project is archived.
+ */
+const ProjectArchivedPayload = defineSchemaModel({
+  name: 'ProjectArchivedPayload',
+  description: 'Payload when a project is archived',
+  fields: {
+    projectId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    archivedBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    archivedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+  },
+});
+
+/**
+ * Event: A new project has been created.
+ */
+export const ProjectCreatedEvent = defineEvent({
+  meta: {
+    key: 'project.created',
+    version: '1.0.0',
+    description: 'A new project has been created.',
+    stability: 'stable',
+    owners: ['@saas-team'],
+    tags: ['project', 'created'],
+  },
+  payload: ProjectCreatedPayload,
+});
+
+/**
+ * Event: A project has been updated.
+ */
+export const ProjectUpdatedEvent = defineEvent({
+  meta: {
+    key: 'project.updated',
+    version: '1.0.0',
+    description: 'A project has been updated.',
+    stability: 'stable',
+    owners: ['@saas-team'],
+    tags: ['project', 'updated'],
+  },
+  payload: ProjectUpdatedPayload,
+});
+
+/**
+ * Event: A project has been deleted.
+ */
+export const ProjectDeletedEvent = defineEvent({
+  meta: {
+    key: 'project.deleted',
+    version: '1.0.0',
+    description: 'A project has been deleted.',
+    stability: 'stable',
+    owners: ['@saas-team'],
+    tags: ['project', 'deleted'],
+  },
+  payload: ProjectDeletedPayload,
+});
+
+/**
+ * Event: A project has been archived.
+ */
+export const ProjectArchivedEvent = defineEvent({
+  meta: {
+    key: 'project.archived',
+    version: '1.0.0',
+    description: 'A project has been archived.',
+    stability: 'stable',
+    owners: ['@saas-team'],
+    tags: ['project', 'archived'],
+  },
+  payload: ProjectArchivedPayload,
+});

package/src/project/project.handler.ts

@@ -0,0 +1,168 @@
+/**
+ * Mock handlers for Project contracts.
+ */
+import { MOCK_PROJECTS } from '../shared/mock-data';
+
+// Types inferred from contract schemas
+export interface Project {
+  id: string;
+  name: string;
+  description?: string;
+  slug?: string;
+  organizationId: string;
+  createdBy: string;
+  status: 'DRAFT' | 'ACTIVE' | 'ARCHIVED' | 'DELETED';
+  isPublic: boolean;
+  tags: string[];
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface CreateProjectInput {
+  name: string;
+  description?: string;
+  slug?: string;
+  isPublic?: boolean;
+  tags?: string[];
+}
+
+export interface UpdateProjectInput {
+  projectId: string;
+  name?: string;
+  description?: string;
+  slug?: string;
+  isPublic?: boolean;
+  tags?: string[];
+  status?: 'DRAFT' | 'ACTIVE' | 'ARCHIVED' | 'DELETED';
+}
+
+export interface ListProjectsInput {
+  status?: 'DRAFT' | 'ACTIVE' | 'ARCHIVED' | 'all';
+  search?: string;
+  limit?: number;
+  offset?: number;
+}
+
+export interface ListProjectsOutput {
+  projects: Project[];
+  total: number;
+}
+
+/**
+ * Mock handler for ListProjectsContract.
+ */
+export async function mockListProjectsHandler(
+  input: ListProjectsInput
+): Promise<ListProjectsOutput> {
+  const { status, search, limit = 20, offset = 0 } = input;
+
+  let filtered = [...MOCK_PROJECTS];
+
+  if (status && status !== 'all') {
+    filtered = filtered.filter((p) => p.status === status);
+  }
+
+  if (search) {
+    const q = search.toLowerCase();
+    filtered = filtered.filter(
+      (p) =>
+        p.name.toLowerCase().includes(q) ||
+        p.description?.toLowerCase().includes(q) ||
+        p.tags.some((t) => t.toLowerCase().includes(q))
+    );
+  }
+
+  filtered.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+
+  const total = filtered.length;
+  const projects = filtered.slice(offset, offset + limit);
+
+  return {
+    projects,
+    total,
+  };
+}
+
+/**
+ * Mock handler for GetProjectContract.
+ */
+export async function mockGetProjectHandler(input: {
+  projectId: string;
+}): Promise<Project> {
+  const project = MOCK_PROJECTS.find((p) => p.id === input.projectId);
+
+  if (!project) {
+    throw new Error('NOT_FOUND');
+  }
+
+  return project;
+}
+
+/**
+ * Mock handler for CreateProjectContract.
+ */
+export async function mockCreateProjectHandler(
+  input: CreateProjectInput,
+  context: { organizationId: string; userId: string }
+): Promise<Project> {
+  if (input.slug) {
+    const exists = MOCK_PROJECTS.some((p) => p.slug === input.slug);
+    if (exists) {
+      throw new Error('SLUG_EXISTS');
+    }
+  }
+
+  const now = new Date();
+  return {
+    id: `proj-${Date.now()}`,
+    name: input.name,
+    description: input.description,
+    slug: input.slug ?? input.name.toLowerCase().replace(/\s+/g, '-'),
+    organizationId: context.organizationId,
+    createdBy: context.userId,
+    status: 'DRAFT',
+    isPublic: input.isPublic ?? false,
+    tags: input.tags ?? [],
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+/**
+ * Mock handler for UpdateProjectContract.
+ */
+export async function mockUpdateProjectHandler(
+  input: UpdateProjectInput
+): Promise<Project> {
+  const project = MOCK_PROJECTS.find((p) => p.id === input.projectId);
+
+  if (!project) {
+    throw new Error('NOT_FOUND');
+  }
+
+  return {
+    ...project,
+    name: input.name ?? project.name,
+    description: input.description ?? project.description,
+    slug: input.slug ?? project.slug,
+    isPublic: input.isPublic ?? project.isPublic,
+    tags: input.tags ?? project.tags,
+    status: input.status ?? project.status,
+    updatedAt: new Date(),
+  };
+}
+
+/**
+ * Mock handler for DeleteProjectContract.
+ */
+export async function mockDeleteProjectHandler(input: {
+  projectId: string;
+}): Promise<{ success: boolean }> {
+  const project = MOCK_PROJECTS.find((p) => p.id === input.projectId);
+
+  if (!project) {
+    throw new Error('NOT_FOUND');
+  }
+
+  return { success: true };
+}