@foundrynorth/compass-schema 1.0.13 → 1.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foundrynorth/compass-schema",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "Canonical Drizzle ORM schema for Foundry Compass (rough-waterfall database)",
   "type": "module",
   "main": "dist/index.js",

package/src/relations.ts

@@ -15,6 +15,11 @@ import {
   semCampaigns,
   mediaOrders,
   mediaOrderLineItems,
+  planOptions,
+  researchSnapshots,
+  researchRuns,
+  engagements,
+  planConfigurations,
 } from "./schema.js";
 
 export const deepEnrichmentUsageRelations = relations(deepEnrichmentUsage, ({one}) => ({
@@ -24,9 +29,16 @@ export const deepEnrichmentUsageRelations = relations(deepEnrichmentUsage, ({one
   }),
 }));
 
-export const plansRelations = relations(plans, ({many}) => ({
+export const plansRelations = relations(plans, ({one, many}) => ({
   deepEnrichmentUsages: many(deepEnrichmentUsage),
   planEnrichments: many(planEnrichments),
+  planOptions: many(planOptions),
+  researchSnapshots: many(researchSnapshots),
+  researchRuns: many(researchRuns),
+  selectedOption: one(planOptions, {
+    fields: [plans.selectedOptionId],
+    references: [planOptions.id],
+  }),
 }));
 
 export const pdfTemplateFieldMappingsRelations = relations(pdfTemplateFieldMappings, ({one}) => ({
@@ -98,6 +110,54 @@ export const googleAdSearchesRelations = relations(googleAdSearches, ({many}) =>
   googleAdCreatives: many(googleAdCreatives),
 }));
 
+/** Canonical planning model relations */
+export const researchSnapshotsRelations = relations(researchSnapshots, ({one, many}) => ({
+  plan: one(plans, {
+    fields: [researchSnapshots.planId],
+    references: [plans.id],
+  }),
+  engagement: one(engagements, {
+    fields: [researchSnapshots.engagementId],
+    references: [engagements.id],
+  }),
+  planOptions: many(planOptions),
+  researchRuns: many(researchRuns),
+}));
+
+export const planOptionsRelations = relations(planOptions, ({one}) => ({
+  plan: one(plans, {
+    fields: [planOptions.planId],
+    references: [plans.id],
+  }),
+  engagement: one(engagements, {
+    fields: [planOptions.engagementId],
+    references: [engagements.id],
+  }),
+  legacyConfiguration: one(planConfigurations, {
+    fields: [planOptions.legacyConfigurationId],
+    references: [planConfigurations.id],
+  }),
+  researchSnapshot: one(researchSnapshots, {
+    fields: [planOptions.researchSnapshotId],
+    references: [researchSnapshots.id],
+  }),
+}));
+
+export const researchRunsRelations = relations(researchRuns, ({one}) => ({
+  plan: one(plans, {
+    fields: [researchRuns.planId],
+    references: [plans.id],
+  }),
+  engagement: one(engagements, {
+    fields: [researchRuns.engagementId],
+    references: [engagements.id],
+  }),
+  researchSnapshot: one(researchSnapshots, {
+    fields: [researchRuns.researchSnapshotId],
+    references: [researchSnapshots.id],
+  }),
+}));
+
 /** SEM campaign relations — links to media order and line item. */
 export const semCampaignsRelations = relations(semCampaigns, ({ one }) => ({
   mediaOrder: one(mediaOrders, {

package/src/schema.ts

@@ -1025,6 +1025,7 @@ export const plans = pgTable("plans", {
   // Partner association (null = legacy plans before partner system)
   partnerId: varchar("partner_id"),
   engagementId: varchar("engagement_id"), // FK → engagements.id (nullable for backward compatibility)
+  selectedOptionId: varchar("selected_option_id"), // FK → plan_options.id (nullable during migration)
   contractId: uuid("contract_id"), // FK → contracts.id (nullable — links to annual contract)
 
   // Workflow mode: determines which UI sections and features are available
@@ -1255,6 +1256,7 @@ export const proposals = pgTable(
 
     // Configuration references (which plan_configurations to include)
     configurationIds: jsonb("configuration_ids").$type<string[]>(),
+    optionIds: jsonb("option_ids").$type<string[]>(),
 
     // Organization
     partnerId: varchar("partner_id"),
@@ -1363,6 +1365,195 @@ export const insertPlanConfigurationSchema = createInsertSchema(planConfiguratio
 export type InsertPlanConfiguration = z.infer<typeof insertPlanConfigurationSchema>;
 export type PlanConfiguration = typeof planConfigurations.$inferSelect;
 
+// Canonical planning model enums
+export const planOptionSourceEnum = pgEnum("plan_option_source", [
+  "strategist",
+  "ai",
+  "derived_snapshot",
+]);
+
+export const planOptionKindEnum = pgEnum("plan_option_kind", [
+  "base",
+  "alternative",
+]);
+
+export const planOptionStatusEnum = pgEnum("plan_option_status", [
+  "draft",
+  "recommended",
+  "selected",
+  "ordered",
+  "archived",
+]);
+
+export const researchRunStatusEnum = pgEnum("research_run_status", [
+  "queued",
+  "running",
+  "completed",
+  "failed",
+  "cancelled",
+  "reused",
+]);
+
+// Canonical research snapshot store
+export const researchSnapshots = pgTable(
+  "research_snapshots",
+  {
+    id: varchar("id")
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    engagementId: varchar("engagement_id").references(() => engagements.id, {
+      onDelete: "set null",
+    }),
+    planId: varchar("plan_id")
+      .notNull()
+      .references(() => plans.id, { onDelete: "cascade" }),
+    scopeType: text("scope_type").notNull(),
+    scopeKey: text("scope_key").notNull(),
+    sourceMode: text("source_mode").notNull(),
+    snapshotVersion: integer("snapshot_version").notNull().default(1),
+    prospectProfile: jsonb("prospect_profile").$type<Record<string, any>>(),
+    competitiveContext: jsonb("competitive_context").$type<Record<string, any>>(),
+    marketContext: jsonb("market_context").$type<Record<string, any>>(),
+    constraints: jsonb("constraints").$type<Record<string, any>>(),
+    fulfillmentContext: jsonb("fulfillment_context").$type<Record<string, any>>(),
+    brandContext: jsonb("brand_context").$type<Record<string, any>>(),
+    provenance: jsonb("provenance").$type<Record<string, any>>().notNull(),
+    freshUntil: timestamp("fresh_until"),
+    reuseHash: text("reuse_hash"),
+    triggerRunId: varchar("trigger_run_id"),
+    costMeta: jsonb("cost_meta").$type<Record<string, any>>(),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+    updatedAt: timestamp("updated_at").notNull().defaultNow(),
+  },
+  (table) => [
+    index("research_snapshots_plan_id_idx").on(table.planId),
+    index("research_snapshots_plan_version_idx").on(table.planId, table.snapshotVersion),
+    index("research_snapshots_scope_key_idx").on(table.scopeKey),
+    index("research_snapshots_reuse_hash_idx").on(table.reuseHash),
+  ]
+);
+
+export const insertResearchSnapshotSchema = createInsertSchema(researchSnapshots).omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+});
+
+export type InsertResearchSnapshot = z.infer<typeof insertResearchSnapshotSchema>;
+export type ResearchSnapshot = typeof researchSnapshots.$inferSelect;
+
+// Canonical actionable option store
+export const planOptions = pgTable(
+  "plan_options",
+  {
+    id: varchar("id")
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    planId: varchar("plan_id")
+      .notNull()
+      .references(() => plans.id, { onDelete: "cascade" }),
+    engagementId: varchar("engagement_id").references(() => engagements.id, {
+      onDelete: "set null",
+    }),
+    legacyConfigurationId: varchar("legacy_configuration_id").references(
+      () => planConfigurations.id,
+      { onDelete: "set null" }
+    ),
+    legacyTierKey: text("legacy_tier_key"),
+    name: text("name").notNull(),
+    label: text("label"),
+    source: planOptionSourceEnum("source").notNull(),
+    kind: planOptionKindEnum("kind").notNull(),
+    status: planOptionStatusEnum("status").notNull().default("draft"),
+    derivedFromOptionId: varchar("derived_from_option_id"),
+    researchSnapshotId: varchar("research_snapshot_id").references(
+      () => researchSnapshots.id,
+      { onDelete: "set null" }
+    ),
+    generationRunId: varchar("generation_run_id"),
+    budgetTotal: integer("budget_total"),
+    durationMonths: integer("duration_months"),
+    allocations: jsonb("allocations")
+      .$type<Record<string, any>[]>()
+      .notNull()
+      .default(sql`'[]'::jsonb`),
+    rationale: text("rationale"),
+    assumptions: jsonb("assumptions").$type<Record<string, any>>(),
+    constraints: jsonb("constraints").$type<Record<string, any>>(),
+    fulfillmentNotes: text("fulfillment_notes"),
+    generationContext: jsonb("generation_context").$type<Record<string, any>>(),
+    displayOrder: integer("display_order").notNull().default(0),
+    createdBy: text("created_by"),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+    updatedAt: timestamp("updated_at").notNull().defaultNow(),
+  },
+  (table) => [
+    index("plan_options_plan_id_idx").on(table.planId),
+    index("plan_options_plan_display_order_idx").on(table.planId, table.displayOrder),
+    index("plan_options_engagement_id_idx").on(table.engagementId),
+    index("plan_options_research_snapshot_id_idx").on(table.researchSnapshotId),
+    uniqueIndex("plan_options_one_recommended_idx")
+      .on(table.planId)
+      .where(sql`${table.status} = 'recommended'::plan_option_status`),
+    uniqueIndex("plan_options_one_selected_idx")
+      .on(table.planId)
+      .where(sql`${table.status} = 'selected'::plan_option_status`),
+  ]
+);
+
+export const insertPlanOptionSchema = createInsertSchema(planOptions).omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+});
+
+export type InsertPlanOption = z.infer<typeof insertPlanOptionSchema>;
+export type PlanOption = typeof planOptions.$inferSelect;
+
+// Operational ledger for research runs and snapshot materialization
+export const researchRuns = pgTable(
+  "research_runs",
+  {
+    id: varchar("id")
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    triggerRunId: varchar("trigger_run_id"),
+    taskId: text("task_id").notNull(),
+    engagementId: varchar("engagement_id").references(() => engagements.id, {
+      onDelete: "set null",
+    }),
+    planId: varchar("plan_id").references(() => plans.id, {
+      onDelete: "set null",
+    }),
+    researchSnapshotId: varchar("research_snapshot_id").references(
+      () => researchSnapshots.id,
+      { onDelete: "set null" }
+    ),
+    status: researchRunStatusEnum("status").notNull().default("queued"),
+    requestedBy: text("requested_by"),
+    runReason: text("run_reason"),
+    inputHash: text("input_hash"),
+    costMeta: jsonb("cost_meta").$type<Record<string, any>>(),
+    startedAt: timestamp("started_at"),
+    completedAt: timestamp("completed_at"),
+    error: text("error"),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+  },
+  (table) => [
+    index("research_runs_plan_id_idx").on(table.planId),
+    index("research_runs_trigger_run_id_idx").on(table.triggerRunId),
+    index("research_runs_task_status_idx").on(table.taskId, table.status),
+  ]
+);
+
+export const insertResearchRunSchema = createInsertSchema(researchRuns).omit({
+  id: true,
+  createdAt: true,
+});
+
+export type InsertResearchRun = z.infer<typeof insertResearchRunSchema>;
+export type ResearchRun = typeof researchRuns.$inferSelect;
+
 // Jobs Table for async operations
 export const jobs = pgTable("jobs", {
   id: varchar("id")
@@ -4525,6 +4716,7 @@ export const mediaOrders = pgTable(
     planId: varchar("plan_id"), // FK → plans.id (nullable — can exist without a plan)
     engagementId: varchar("engagement_id"), // FK → engagements.id (nullable during transition)
     configurationId: varchar("configuration_id"), // FK → plan_configurations.id (named product mix)
+    optionId: varchar("option_id"), // FK → plan_options.id (canonical selected option)
     contractId: uuid("contract_id"), // FK → contracts.id (nullable — links to annual contract)
     partnerId: varchar("partner_id"),
     hubspotDealId: text("hubspot_deal_id"),
@@ -8003,3 +8195,14 @@ export const compassEventOutbox = pgTable(
 
 export type CompassEventOutboxRecord = typeof compassEventOutbox.$inferSelect;
 export type InsertCompassEventOutbox = typeof compassEventOutbox.$inferInsert;
+
+// ─── Creative Deliveries (Prism webhook idempotency) ────────────────────────
+
+export const creativeDeliveries = pgTable("creative_deliveries", {
+  id: serial("id").primaryKey(),
+  packageId: varchar("package_id", { length: 255 }).notNull().unique(),
+  compassCampaignId: varchar("compass_campaign_id", { length: 255 }).notNull(),
+  status: varchar("status", { length: 50 }).notNull(),
+  assetCount: integer("asset_count").notNull().default(0),
+  receivedAt: timestamp("received_at").defaultNow().notNull(),
+});