@intelligo-dev/core 1.0.0-beta.13 → 1.0.0-beta.14

package/src/db/migrations/meta/_journal.json

@@ -22,6 +22,13 @@
       "when": 1789808201382,
       "tag": "0002_webhook_claim_lease",
       "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "7",
+      "when": 1790179158533,
+      "tag": "0003_local_payments",
+      "breakpoints": true
     }
   ]
 }

package/src/db/schema/billing.ts

@@ -1,6 +1,7 @@
 /**
- * Plans, subscriptions, credit ledgers, purchases and Stripe events.
- * Amounts in the credit ledgers are micros of their currency.
+ * Plans, subscriptions, credit ledgers, purchases, local payments and
+ * Stripe events. Amounts in the credit ledgers are micros of their
+ * currency; amounts a buyer paid are minor units of theirs.
  */
 
 import {
@@ -13,7 +14,7 @@ import {
   index,
   unique,
 } from "drizzle-orm/pg-core";
-import { organization } from "./auth";
+import { organization, users } from "./auth";
 
 /**
  * The registered plan catalogue, copied into rows so a subscription can
@@ -135,6 +136,39 @@ export const creditPurchases = pgTable(
   (table) => [index("credit_purchases_workspace_id_idx").on(table.workspaceId)]
 );
 
+/**
+ * Invoices issued through a registered payment provider (QR-and-poll
+ * methods such as QPay, PIX or UPI), one row per invoice. The row is
+ * written when the invoice is opened, so settlement knows who pays and
+ * what was priced without trusting the browser; `fulfilled_at` is set
+ * in the same transaction that grants what was bought, so a payment is
+ * granted once however many polls see it paid.
+ */
+export const payments = pgTable(
+  "payments",
+  {
+    id: text("id").primaryKey(),
+    /** The PAYMENT_MODE the invoice was opened under; settlement asks the same provider. */
+    provider: text("provider").notNull(),
+    invoiceId: text("invoice_id").notNull().unique(),
+    workspaceId: text("workspace_id")
+      .notNull()
+      .references(() => organization.id, { onDelete: "cascade" }),
+    userId: text("user_id").references(() => users.id, {
+      onDelete: "set null",
+    }),
+    /** What was bought, in the product's words: a plan slug, a bundle id. */
+    reference: text("reference").notNull(),
+    /** The price, in minor units of `currency`. */
+    amountMinor: integer("amount_minor").notNull(),
+    currency: text("currency").notNull(),
+    status: text("status").notNull().default("pending"), // pending|paid|failed
+    fulfilledAt: timestamp("fulfilled_at"),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+  },
+  (table) => [index("payments_workspace_id_idx").on(table.workspaceId)]
+);
+
 /** Every Stripe event, for idempotent webhook processing and audit. */
 export const financeEvents = pgTable("finance_events", {
   id: text("id").primaryKey(),
@@ -201,6 +235,8 @@ export type CreditBalance = typeof creditBalances.$inferSelect;
 export type InsertCreditBalance = typeof creditBalances.$inferInsert;
 export type CreditPurchase = typeof creditPurchases.$inferSelect;
 export type InsertCreditPurchase = typeof creditPurchases.$inferInsert;
+export type Payment = typeof payments.$inferSelect;
+export type InsertPayment = typeof payments.$inferInsert;
 export type FinanceEvent = typeof financeEvents.$inferSelect;
 export type InsertFinanceEvent = typeof financeEvents.$inferInsert;
 export type BillingSettings = typeof billingSettings.$inferSelect;

package/src/identity/index.ts

@@ -1,11 +1,13 @@
 /**
  * Privacy-facing reads and mutations over the user identity graph: fact
- * listing and deletion, full-identity export, and the memory-audit trail.
+ * listing and deletion, the profile snapshot's write, full-identity
+ * export, and the memory-audit trail.
  */
 
 export {
   listFacts,
   deleteFact,
+  saveProfileSnapshot,
   exportIdentity,
   getAuditTrail,
 } from "./service";
@@ -19,6 +21,7 @@ export {
 export type {
   IdentityActor,
   IdentityExport,
+  SaveProfileSnapshotInput,
   UserFact,
   UserMemory,
   UserProfileSnapshot,

package/src/identity/service.ts

@@ -1,16 +1,18 @@
 /**
  * Server-only reads and mutations over the user identity graph: fact
- * listing and deletion, a full data export, and the memory-audit trail.
+ * listing and deletion, the profile snapshot's write, a full data export,
+ * and the memory-audit trail.
  *
  * `deleteFact` does not touch the cached profile snapshot; profile synthesis
- * is the product's AI code, so a caller that owns it re-triggers it.
+ * is the product's AI code, so a caller that owns it re-triggers it and
+ * stores the result with `saveProfileSnapshot`.
  *
  * Callers pass a resolved actor (workspaceId, userId); core cannot depend on
  * `@intelligo-dev/auth`. Every query filters by both ids. Every mutation
  * writes a `user_memory_audit` row. Failures throw `IdentityServiceError`.
  */
 
-import { and, desc, eq } from "drizzle-orm";
+import { and, desc, eq, sql } from "drizzle-orm";
 import { db } from "../db";
 import {
   userFacts,
@@ -18,10 +20,18 @@ import {
   userProfileSnapshots,
   userMemoryAudit,
 } from "../db/schema";
-import type { UserFact, UserMemoryAuditRow } from "../db/schema";
+import type {
+  UserFact,
+  UserMemoryAuditRow,
+  UserProfileSnapshot,
+} from "../db/schema";
 import { recordMemoryAudit } from "./audit";
 import { IdentityServiceError } from "./errors";
-import type { IdentityActor, IdentityExport } from "./types";
+import type {
+  IdentityActor,
+  IdentityExport,
+  SaveProfileSnapshotInput,
+} from "./types";
 
 /**
  * Returns the fact if the actor owns it. Throws
@@ -200,3 +210,94 @@ export async function exportIdentity(
     audit,
   };
 }
+
+/**
+ * Store the actor's synthesized profile — one row per user per workspace,
+ * inserted on the first synthesis and replaced on every later one. The
+ * version is bumped in the same statement (`ON CONFLICT … version + 1`),
+ * so two syntheses racing each other get two versions rather than one
+ * overwriting the other's number; it starts at 1.
+ *
+ * A field left `undefined` keeps what the row holds (null on insert); an
+ * explicit `null` clears it. `synthesizedAt` defaults to now. Records an
+ * audit row (`snapshot`, `create` or `update`) in the same transaction,
+ * attributed to `input.actorKind` — `system_job` unless the caller says
+ * otherwise. Throws `invalid_input` for an empty summary.
+ */
+export async function saveProfileSnapshot(
+  actor: IdentityActor,
+  input: SaveProfileSnapshotInput
+): Promise<UserProfileSnapshot> {
+  if (!input.summary || input.summary.trim().length === 0) {
+    throw new IdentityServiceError("invalid_input", "summary is required");
+  }
+  if (input.factsDigest === undefined || input.factsDigest === null) {
+    throw new IdentityServiceError("invalid_input", "factsDigest is required");
+  }
+
+  const replaced = {
+    summary: input.summary,
+    factsDigest: input.factsDigest,
+    synthesizedAt: input.synthesizedAt ?? new Date(),
+    ...definedOnly({
+      summaryEn: input.summaryEn,
+      summaryMn: input.summaryMn,
+      activeGoals: input.activeGoals,
+      personalitySignals: input.personalitySignals,
+      relationshipNotes: input.relationshipNotes,
+      synthesizedByModel: input.synthesizedByModel,
+      nextSynthesisAt: input.nextSynthesisAt,
+      triggerReason: input.triggerReason,
+    }),
+  };
+
+  return db.transaction(async (tx) => {
+    const [row] = await tx
+      .insert(userProfileSnapshots)
+      .values({
+        userId: actor.userId,
+        workspaceId: actor.workspaceId,
+        version: 1,
+        ...replaced,
+      })
+      .onConflictDoUpdate({
+        target: [userProfileSnapshots.userId, userProfileSnapshots.workspaceId],
+        set: {
+          ...replaced,
+          version: sql`${userProfileSnapshots.version} + 1`,
+        },
+      })
+      .returning();
+
+    if (!row) {
+      throw new IdentityServiceError(
+        "database_error",
+        "Failed to save profile snapshot"
+      );
+    }
+
+    await recordMemoryAudit(
+      {
+        userId: actor.userId,
+        workspaceId: actor.workspaceId,
+        targetKind: "snapshot",
+        targetId: actor.userId,
+        action: row.version === 1 ? "create" : "update",
+        actorKind: input.actorKind ?? "system_job",
+        actorId: input.actorId,
+        afterValue: { version: row.version, triggerReason: row.triggerReason },
+        reason: input.reason,
+      },
+      tx
+    );
+
+    return row;
+  });
+}
+
+/** The entries whose value is not `undefined` — `null` is kept, to clear. */
+function definedOnly<T extends Record<string, unknown>>(fields: T): Partial<T> {
+  return Object.fromEntries(
+    Object.entries(fields).filter(([, value]) => value !== undefined)
+  ) as Partial<T>;
+}

package/src/identity/types.ts

@@ -1,4 +1,6 @@
 import type {
+  AuditActorKind,
+  SynthesisTriggerReason,
   UserFact,
   UserMemory,
   UserProfileSnapshot,
@@ -26,3 +28,31 @@ export type IdentityExport = {
   snapshot: UserProfileSnapshot | null;
   audit: UserMemoryAuditRow[];
 };
+
+/**
+ * A synthesized profile, as `saveProfileSnapshot` stores it. The actor
+ * supplies the tenancy; the version is the store's.
+ */
+export type SaveProfileSnapshotInput = {
+  /** The summary a prompt hydrates from, in the product's primary language. */
+  summary: string;
+  summaryEn?: string | null;
+  summaryMn?: string | null;
+  /** The structured digest the summary was written from. */
+  factsDigest: unknown;
+  activeGoals?: unknown;
+  personalitySignals?: unknown;
+  relationshipNotes?: unknown;
+  /** The model that wrote it, or a label for a deterministic synthesis. */
+  synthesizedByModel?: string | null;
+  /** Default: now. */
+  synthesizedAt?: Date;
+  /** When a scheduled re-synthesis may next pick this user up. */
+  nextSynthesisAt?: Date | null;
+  triggerReason?: SynthesisTriggerReason | null;
+  /** Who the audit row names. Default `"system_job"`. */
+  actorKind?: AuditActorKind;
+  actorId?: string;
+  /** Recorded on the audit row. */
+  reason?: string;
+};

package/src/notifications/index.ts

@@ -8,7 +8,11 @@ import { notifications } from "../db/schema";
 import { eq, and, desc, count } from "drizzle-orm";
 import type { CreateNotificationParams } from "./types";
 
-export type { NotificationType, CreateNotificationParams } from "./types";
+export type {
+  BuiltInNotificationType,
+  NotificationType,
+  CreateNotificationParams,
+} from "./types";
 
 export {
   triggerQuotaNotification,

package/src/notifications/types.ts

@@ -1,4 +1,5 @@
-export type NotificationType =
+/** The notification types the framework itself creates. */
+export type BuiltInNotificationType =
   | "quota_warning_80"
   | "quota_warning_100"
   | "trial_warning_20"
@@ -8,6 +9,13 @@ export type NotificationType =
   | "subscription_confirmed"
   | "workspace_invitation";
 
+/**
+ * A notification's `type`: one of the built-in types, or any string a
+ * product defines for its own notifications. `(string & {})` keeps the
+ * built-in names offered by autocompletion.
+ */
+export type NotificationType = BuiltInNotificationType | (string & {});
+
 export interface CreateNotificationParams {
   userId: string;
   workspaceId?: string;