@mirafive/convex 0.0.0-stage → 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cloo GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,97 @@
-# Temporary Holding Version
+# @mirafive/convex
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+MIRA FIVE for [Convex](https://convex.dev): track events and revenue from mutations. A mutation
+cannot use the network, so the event is scheduled in the same transaction and an internal action
+delivers it right after the commit. A mutation that rolls back sends nothing, so an order that
+never happened is never counted. Built on [`@mirafive/node`](https://github.com/mirafive/sdk-node);
+no dependency on `convex`, and it runs in Convex's default runtime (no `"use node"`).
+
+## Install
+
+```sh
+npm install @mirafive/convex
+npx convex env set MIRAFIVE_SECRET_KEY mira_sk_…
+```
+
+## Setup
+
+```ts
+// convex/mira.ts
+import { MiraConvex } from "@mirafive/convex";
+import { v } from "convex/values";
+
+import { internal } from "./_generated/api";
+import { internalAction } from "./_generated/server";
+
+// The `: MiraConvex` annotation is required: it breaks the type cycle through `internal`.
+export const mira: MiraConvex = new MiraConvex(internal.mira.deliver);
+
+export const deliver = internalAction({
+  args: { events: v.array(v.any()) },
+  handler: (_ctx, { events }) => mira.deliver(events),
+});
+```
+
+## Use
+
+```ts
+// convex/orders.ts
+import { v } from "convex/values";
+
+import { mutation } from "./_generated/server";
+import { mira } from "./mira";
+
+export const pay = mutation({
+  args: { orderId: v.id("orders") },
+  handler: async (ctx, { orderId }) => {
+    const order = await ctx.db.get(orderId);
+    await ctx.db.patch(orderId, { status: "paid" });
+    await mira.revenue(ctx, {
+      userId: order.userId,
+      amount: order.totalCents,
+      currency: "EUR",
+      entryId: `order:${orderId}`,
+      // A stable key: a retried mutation schedules the event again, the ingest counts it once.
+      dedupeKey: `order:${orderId}:paid`,
+    });
+  },
+});
+```
+
+| Method                                                                        | Sends                                                                                 |
+| ----------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
+| `mira.track(ctx, { event, userId?, properties?, … })`                         | A custom event                                                                        |
+| `mira.identify(ctx, { userId, traits?, externalIds? })`                       | Who the user is                                                                       |
+| `mira.group(ctx, { groupId, traits? })`                                       | The company or account                                                                |
+| `mira.revenue(ctx, { amount, currency, entryId?, subscription?, … })`         | Money for the revenue ledger                                                          |
+| `mira.touchpoint(ctx, { kind, source \| channel, userId \| anonymousId, … })` | A touchpoint that is not a visit                                                      |
+| `mira.schedule(ctx, events)`                                                  | Several at once (`{ method: "track", … }`)                                            |
+| `mira.deliver(events)`                                                        | Sends now; for the internal action. Returns `{ sent, failed, errors }`, never throws. |
+
+Every method takes the same fields as [`@mirafive/node`](https://github.com/mirafive/sdk-node#readme)
+plus `dedupeKey`. `Date` values are converted for the scheduler. Scheduling never fails your
+mutation: a problem goes to `onError` (`new MiraConvex(ref, { onError })`).
+
+## For AI coding assistants
+
+Rules for integrating MIRA FIVE correctly. They hold for every MIRA FIVE SDK.
+
+- **Keys:** the public key (`mira_pk_…`) goes in browser and app code. The secret key (`mira_sk_…`)
+  goes only into the server's environment (`MIRAFIVE_SECRET_KEY`), never into client code, a
+  `NEXT_PUBLIC_`/`VITE_`/`PUBLIC_` variable or a repository. The SDKs refuse the wrong key.
+- **Money** is sent only from the server: integer minor units plus an ISO 4217 currency
+  (`amount: 1999, currency: "EUR"` is 19.99 EUR), never floats.
+- **Count once:** give money an `entryId` from the payment provider (`stripe:in_123`), so the
+  Stripe connector and retries do not double it. Give business events a stable id:
+  `eventId: await eventIdFor("order:123:paid")`. The same key gives the same id in every SDK.
+- **Personal data** never goes into event names or properties. Use your own user id (not an email)
+  for `identify`; put email, name and phone in its traits, which MIRA FIVE encrypts at rest.
+- **Consent:** keep `consent: "auto"`; it follows the site's consent banner (Usercentrics,
+  Cookiebot, consentmanager, CCM19, Borlabs, any TCF 2.2 CMP, Google Consent Mode). Call
+  `consent()` only for a custom banner. Do not gate the SDK behind consent yourself: without
+  consent it is cookieless and still counts.
+- **Never block on analytics:** event methods return nothing, never throw, and batch on their
+  own. Do not `await` or `try` them. Call `flush()`/`shutdown()` only at the end of a script or a
+  serverless function.
+- **Server events and visitors:** pass the browser's `mira.anonymousId` to your server and set it
+  as `anonymousId` on server events, so a purchase joins the visit and its source.

package/dist/index.d.ts

@@ -0,0 +1,83 @@
+/**
+ * `@mirafive/convex`: MIRA FIVE events from Convex mutations and actions.
+ *
+ * Mutations are transactional and cannot use the network, so an event is scheduled with
+ * `ctx.scheduler` in the same transaction and delivered by an internal action right after it
+ * commits. A mutation that rolls back sends nothing, so an order that never happened is never
+ * counted. No dependency on `convex`; it runs in Convex's default runtime (no `"use node"`).
+ *
+ * ```ts
+ * // convex/mira.ts
+ * import { MiraConvex } from "@mirafive/convex";
+ * import { v } from "convex/values";
+ * import { internal } from "./_generated/api";
+ * import { internalAction } from "./_generated/server";
+ *
+ * // The `: MiraConvex` annotation is required: it breaks the type cycle through `internal`.
+ * export const mira: MiraConvex = new MiraConvex(internal.mira.deliver);
+ *
+ * export const deliver = internalAction({
+ *   args: { events: v.array(v.any()) },
+ *   handler: (_ctx, { events }) => mira.deliver(events),
+ * });
+ *
+ * // convex/orders.ts, in a mutation
+ * await mira.revenue(ctx, { userId, amount: 4900, currency: "EUR", dedupeKey: `order:${id}:paid` });
+ * ```
+ */
+import { type EventMap, type GroupInput, type IdentifyInput, type MiraOptions, type RevenueInput, type TouchpointInput, type TrackInput } from "@mirafive/node";
+export { eventIdFor, MiraError } from "@mirafive/node";
+export type { EventMap, GroupInput, IdentifyInput, MiraOptions, RevenueInput, TouchpointInput, TrackInput, } from "@mirafive/node";
+/** A stable key (`order:123:paid`) that becomes the event id, so a retried mutation counts once. */
+interface Dedupe {
+    dedupeKey?: string;
+}
+/** One event as it travels through `ctx.scheduler`: the method, its input and a dedupe key. */
+export type MiraEvent = ({
+    method: "track";
+} & TrackInput & Dedupe) | ({
+    method: "identify";
+} & IdentifyInput & Dedupe) | ({
+    method: "group";
+} & GroupInput & Dedupe) | ({
+    method: "revenue";
+} & RevenueInput & Dedupe) | ({
+    method: "touchpoint";
+} & TouchpointInput & Dedupe);
+/** The part of a Convex mutation or action context this package uses. */
+export interface SchedulerCtx {
+    scheduler: {
+        runAfter: (delayMs: number, fn: never, args: never) => Promise<unknown>;
+    };
+}
+export interface DeliverResult {
+    sent: number;
+    failed: number;
+    errors: string[];
+}
+export declare class MiraConvex<Events extends EventMap = EventMap> {
+    /**
+     * @param deliverFunction The internal action that calls `mira.deliver(events)`, for example
+     *   `internal.mira.deliver`.
+     * @param options Delivery options. The key defaults to the deployment's `MIRAFIVE_SECRET_KEY`
+     *   (`npx convex env set MIRAFIVE_SECRET_KEY mira_sk_…`) and the host to `MIRAFIVE_HOST`.
+     */
+    private readonly deliverFunction;
+    private readonly options;
+    constructor(deliverFunction: unknown, options?: MiraOptions);
+    /** A custom event, sent after the current mutation commits. */
+    track<Name extends keyof Events & string>(ctx: SchedulerCtx, input: TrackInput<Events, Name> & Dedupe): Promise<void>;
+    identify(ctx: SchedulerCtx, input: IdentifyInput & Dedupe): Promise<void>;
+    group(ctx: SchedulerCtx, input: GroupInput & Dedupe): Promise<void>;
+    /** Money for the revenue ledger. Give it a `dedupeKey` or `entryId`, so a retry counts once. */
+    revenue(ctx: SchedulerCtx, input: RevenueInput & Dedupe): Promise<void>;
+    touchpoint(ctx: SchedulerCtx, input: TouchpointInput & Dedupe): Promise<void>;
+    /** Several events in one scheduled delivery. */
+    schedule(ctx: SchedulerCtx, events: MiraEvent[]): Promise<void>;
+    /**
+     * Sends events now and waits for delivery. The internal action's handler calls it; never call
+     * it from a mutation or query (they cannot use the network). Never throws: a MIRA FIVE outage
+     * must not fail your action. Problems are in `errors`.
+     */
+    deliver(events: MiraEvent[]): Promise<DeliverResult>;
+}

package/dist/index.js

@@ -0,0 +1,98 @@
+// src/index.ts
+import {
+  eventIdFor,
+  Mira,
+  MiraError
+} from "@mirafive/node";
+import { eventIdFor as eventIdFor2, MiraError as MiraError2 } from "@mirafive/node";
+var toConvexValue = (event) => JSON.parse(JSON.stringify(event));
+
+class MiraConvex {
+  deliverFunction;
+  options;
+  constructor(deliverFunction, options = {}) {
+    this.deliverFunction = deliverFunction;
+    this.options = options;
+  }
+  track(ctx, input) {
+    return this.schedule(ctx, [{ method: "track", ...input }]);
+  }
+  identify(ctx, input) {
+    return this.schedule(ctx, [{ method: "identify", ...input }]);
+  }
+  group(ctx, input) {
+    return this.schedule(ctx, [{ method: "group", ...input }]);
+  }
+  revenue(ctx, input) {
+    return this.schedule(ctx, [{ method: "revenue", ...input }]);
+  }
+  touchpoint(ctx, input) {
+    return this.schedule(ctx, [{ method: "touchpoint", ...input }]);
+  }
+  async schedule(ctx, events) {
+    if (!events.length)
+      return;
+    try {
+      await ctx.scheduler.runAfter(0, this.deliverFunction, {
+        events: events.map(toConvexValue)
+      });
+    } catch (error) {
+      this.options.onError?.(new MiraError("dropped", "could not schedule delivery", { cause: error }));
+    }
+  }
+  async deliver(events) {
+    const errors = [];
+    const failedIds = new Set;
+    let invalid = 0;
+    const mira = new Mira({
+      maxRetries: 3,
+      ...this.options,
+      flushAt: 100,
+      onError: (error) => {
+        errors.push(error.message);
+        for (const id of error.eventIds)
+          failedIds.add(id);
+        this.options.onError?.(error);
+      }
+    });
+    if (errors.length)
+      return { sent: 0, failed: events.length, errors };
+    for (const item of events) {
+      const before = errors.length;
+      const eventId = item.eventId ?? (item.dedupeKey ? await eventIdFor(item.dedupeKey) : undefined);
+      const { method, dedupeKey: _, ...input } = item;
+      switch (method) {
+        case "track":
+          mira.track({ ...input, eventId });
+          break;
+        case "identify":
+          mira.identify({ ...input, eventId });
+          break;
+        case "group":
+          mira.group({ ...input, eventId });
+          break;
+        case "revenue":
+          mira.revenue({ ...input, eventId });
+          break;
+        case "touchpoint":
+          mira.touchpoint({ ...input, eventId });
+          break;
+        default:
+          errors.push(`MIRA FIVE: unknown method: ${String(method)}`);
+      }
+      if (errors.length > before)
+        invalid += 1;
+    }
+    await mira.shutdown();
+    const failed = invalid + failedIds.size;
+    return { sent: Math.max(0, events.length - failed), failed, errors };
+  }
+}
+export {
+  MiraConvex,
+  MiraError2 as MiraError,
+  eventIdFor2 as eventIdFor
+};
+
+//# debugId=21BF33B329BC4D5064756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": [
+    "/**\n * `@mirafive/convex`: MIRA FIVE events from Convex mutations and actions.\n *\n * Mutations are transactional and cannot use the network, so an event is scheduled with\n * `ctx.scheduler` in the same transaction and delivered by an internal action right after it\n * commits. A mutation that rolls back sends nothing, so an order that never happened is never\n * counted. No dependency on `convex`; it runs in Convex's default runtime (no `\"use node\"`).\n *\n * ```ts\n * // convex/mira.ts\n * import { MiraConvex } from \"@mirafive/convex\";\n * import { v } from \"convex/values\";\n * import { internal } from \"./_generated/api\";\n * import { internalAction } from \"./_generated/server\";\n *\n * // The `: MiraConvex` annotation is required: it breaks the type cycle through `internal`.\n * export const mira: MiraConvex = new MiraConvex(internal.mira.deliver);\n *\n * export const deliver = internalAction({\n *   args: { events: v.array(v.any()) },\n *   handler: (_ctx, { events }) => mira.deliver(events),\n * });\n *\n * // convex/orders.ts, in a mutation\n * await mira.revenue(ctx, { userId, amount: 4900, currency: \"EUR\", dedupeKey: `order:${id}:paid` });\n * ```\n */\nimport {\n  eventIdFor,\n  Mira,\n  MiraError,\n  type EventMap,\n  type GroupInput,\n  type IdentifyInput,\n  type MiraOptions,\n  type RevenueInput,\n  type TouchpointInput,\n  type TrackInput,\n} from \"@mirafive/node\";\n\nexport { eventIdFor, MiraError } from \"@mirafive/node\";\nexport type {\n  EventMap,\n  GroupInput,\n  IdentifyInput,\n  MiraOptions,\n  RevenueInput,\n  TouchpointInput,\n  TrackInput,\n} from \"@mirafive/node\";\n\n/** A stable key (`order:123:paid`) that becomes the event id, so a retried mutation counts once. */\ninterface Dedupe {\n  dedupeKey?: string;\n}\n\n/** One event as it travels through `ctx.scheduler`: the method, its input and a dedupe key. */\nexport type MiraEvent =\n  | ({ method: \"track\" } & TrackInput & Dedupe)\n  | ({ method: \"identify\" } & IdentifyInput & Dedupe)\n  | ({ method: \"group\" } & GroupInput & Dedupe)\n  | ({ method: \"revenue\" } & RevenueInput & Dedupe)\n  | ({ method: \"touchpoint\" } & TouchpointInput & Dedupe);\n\n/** The part of a Convex mutation or action context this package uses. */\nexport interface SchedulerCtx {\n  scheduler: { runAfter: (delayMs: number, fn: never, args: never) => Promise<unknown> };\n}\n\nexport interface DeliverResult {\n  sent: number;\n  failed: number;\n  errors: string[];\n}\n\n/**\n * Makes an event a Convex value: `Date`s become ISO strings and `undefined` fields disappear,\n * so `ctx.scheduler` accepts it.\n */\nconst toConvexValue = (event: MiraEvent): MiraEvent =>\n  JSON.parse(JSON.stringify(event)) as MiraEvent;\n\nexport class MiraConvex<Events extends EventMap = EventMap> {\n  /**\n   * @param deliverFunction The internal action that calls `mira.deliver(events)`, for example\n   *   `internal.mira.deliver`.\n   * @param options Delivery options. The key defaults to the deployment's `MIRAFIVE_SECRET_KEY`\n   *   (`npx convex env set MIRAFIVE_SECRET_KEY mira_sk_…`) and the host to `MIRAFIVE_HOST`.\n   */\n  private readonly deliverFunction: unknown;\n  private readonly options: MiraOptions;\n\n  constructor(deliverFunction: unknown, options: MiraOptions = {}) {\n    this.deliverFunction = deliverFunction;\n    this.options = options;\n  }\n\n  /** A custom event, sent after the current mutation commits. */\n  track<Name extends keyof Events & string>(\n    ctx: SchedulerCtx,\n    input: TrackInput<Events, Name> & Dedupe,\n  ): Promise<void> {\n    return this.schedule(ctx, [{ method: \"track\", ...(input as TrackInput & Dedupe) }]);\n  }\n\n  identify(ctx: SchedulerCtx, input: IdentifyInput & Dedupe): Promise<void> {\n    return this.schedule(ctx, [{ method: \"identify\", ...input }]);\n  }\n\n  group(ctx: SchedulerCtx, input: GroupInput & Dedupe): Promise<void> {\n    return this.schedule(ctx, [{ method: \"group\", ...input }]);\n  }\n\n  /** Money for the revenue ledger. Give it a `dedupeKey` or `entryId`, so a retry counts once. */\n  revenue(ctx: SchedulerCtx, input: RevenueInput & Dedupe): Promise<void> {\n    return this.schedule(ctx, [{ method: \"revenue\", ...input }]);\n  }\n\n  touchpoint(ctx: SchedulerCtx, input: TouchpointInput & Dedupe): Promise<void> {\n    return this.schedule(ctx, [{ method: \"touchpoint\", ...input }]);\n  }\n\n  /** Several events in one scheduled delivery. */\n  async schedule(ctx: SchedulerCtx, events: MiraEvent[]): Promise<void> {\n    if (!events.length) return;\n    try {\n      await ctx.scheduler.runAfter(\n        0,\n        this.deliverFunction as never,\n        {\n          events: events.map(toConvexValue),\n        } as never,\n      );\n    } catch (error) {\n      // Analytics must never fail the mutation that records the real fact.\n      this.options.onError?.(\n        new MiraError(\"dropped\", \"could not schedule delivery\", { cause: error }),\n      );\n    }\n  }\n\n  /**\n   * Sends events now and waits for delivery. The internal action's handler calls it; never call\n   * it from a mutation or query (they cannot use the network). Never throws: a MIRA FIVE outage\n   * must not fail your action. Problems are in `errors`.\n   */\n  async deliver(events: MiraEvent[]): Promise<DeliverResult> {\n    const errors: string[] = [];\n    const failedIds = new Set<string>();\n    let invalid = 0;\n\n    const mira = new Mira({\n      // Actions have a time limit; fewer retries keep them short.\n      maxRetries: 3,\n      ...this.options,\n      flushAt: 100,\n      onError: (error: MiraError) => {\n        errors.push(error.message);\n        for (const id of error.eventIds) failedIds.add(id);\n        this.options.onError?.(error);\n      },\n    });\n    if (errors.length) return { sent: 0, failed: events.length, errors };\n\n    for (const item of events) {\n      const before = errors.length;\n      const eventId =\n        item.eventId ?? (item.dedupeKey ? await eventIdFor(item.dedupeKey) : undefined);\n      const { method, dedupeKey: _, ...input } = item as MiraEvent & { method: unknown };\n      switch (method) {\n        case \"track\":\n          mira.track({ ...(input as TrackInput), eventId });\n          break;\n        case \"identify\":\n          mira.identify({ ...(input as IdentifyInput), eventId });\n          break;\n        case \"group\":\n          mira.group({ ...(input as GroupInput), eventId });\n          break;\n        case \"revenue\":\n          mira.revenue({ ...(input as RevenueInput), eventId });\n          break;\n        case \"touchpoint\":\n          mira.touchpoint({ ...(input as TouchpointInput), eventId });\n          break;\n        default:\n          errors.push(`MIRA FIVE: unknown method: ${String(method)}`);\n      }\n      if (errors.length > before) invalid += 1;\n    }\n\n    await mira.shutdown();\n    const failed = invalid + failedIds.size;\n    return { sent: Math.max(0, events.length - failed), failed, errors };\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "21BF33B329BC4D5064756E2164756E21",
+  "names": []
+}

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "@mirafive/convex",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.0",
+  "description": "MIRA FIVE for Convex: track events and revenue from mutations; they are delivered by an internal action only after the transaction commits. No dependency on convex.",
+  "keywords": [
+    "analytics",
+    "attribution",
+    "convex",
+    "mira-five",
+    "mirafive",
+    "revenue"
+  ],
+  "homepage": "https://github.com/mirafive/sdk-convex#readme",
+  "bugs": {
+    "url": "https://github.com/mirafive/sdk-convex/issues"
+  },
+  "license": "MIT",
+  "author": "Cloo GmbH <hallo@mirafive.io> (https://mirafive.io)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mirafive/sdk-convex.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "bun run build.ts",
+    "check": "bun run format:check && bun run lint && bun run typecheck && bun run test && bun run build",
+    "format": "oxfmt",
+    "format:check": "oxfmt --check",
+    "lint": "oxlint",
+    "test": "bun test",
+    "typecheck": "bun check"
+  },
+  "dependencies": {
+    "@mirafive/node": "^2.0.0"
+  },
+  "devDependencies": {
+    "@mirafive/protocol": "^2.0.0",
+    "@types/bun": "^1.4.4",
+    "oxfmt": "^0.77.0",
+    "oxlint": "^1.92.0",
+    "oxlint-tsgolint": "^7.0.2006",
+    "typescript": "^7.0.2"
+  },
+  "packageManager": "bun@1.4.4"
+}