@urateam/core 0.1.3 → 0.1.8

package/dist/auth/user-store.d.ts

@@ -0,0 +1,33 @@
+import type { AnyDb } from "../db/client.js";
+import type { Role } from "../rbac/types.js";
+export interface DashboardUser {
+    id: string;
+    email: string;
+    name: string | null;
+    workosUserId: string | null;
+    createdAt: Date;
+    lastLoginAt: Date | null;
+    role: Role;
+}
+export interface UpsertUserInput {
+    email: string;
+    name: string | null;
+    workosUserId: string | null;
+}
+/**
+ * Insert or update a dashboard user by normalized email. Returns the
+ * canonical user id. On update, `name`, `workosUserId`, and `lastLoginAt`
+ * are refreshed; `id` and `createdAt` are preserved.
+ *
+ * Implemented as an atomic upsert (`onConflictDoUpdate` on the unique
+ * `email` column) so that two concurrent `/auth/callback` requests for the
+ * same email cannot both see `existing.length === 0` and race on INSERT.
+ * The generated `id` is only used if no row exists; on conflict we read
+ * back the canonical id from the surviving row.
+ */
+export declare function upsertUser(db: AnyDb, input: UpsertUserInput): Promise<string>;
+/**
+ * Look up a dashboard user by id. Returns `null` when not found.
+ */
+export declare function getUserById(db: AnyDb, id: string): Promise<DashboardUser | null>;
+//# sourceMappingURL=user-store.d.ts.map

package/dist/auth/user-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-store.d.ts","sourceRoot":"","sources":["../../src/auth/user-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAE7C,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,IAAI,CAAC;IAChB,WAAW,EAAE,IAAI,GAAG,IAAI,CAAC;IACzB,IAAI,EAAE,IAAI,CAAC;CACZ;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAMD;;;;;;;;;;GAUG;AACH,wBAAsB,UAAU,CAC9B,EAAE,EAAE,KAAK,EACT,KAAK,EAAE,eAAe,GACrB,OAAO,CAAC,MAAM,CAAC,CAgCjB;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,EAAE,EAAE,KAAK,EACT,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAiB/B"}

package/dist/auth/user-store.js

@@ -0,0 +1,71 @@
+import { randomUUID } from "node:crypto";
+import { eq } from "drizzle-orm";
+import { dashboardUsers } from "../db/schema.js";
+function normalizeEmail(email) {
+    return email.trim().toLowerCase();
+}
+/**
+ * Insert or update a dashboard user by normalized email. Returns the
+ * canonical user id. On update, `name`, `workosUserId`, and `lastLoginAt`
+ * are refreshed; `id` and `createdAt` are preserved.
+ *
+ * Implemented as an atomic upsert (`onConflictDoUpdate` on the unique
+ * `email` column) so that two concurrent `/auth/callback` requests for the
+ * same email cannot both see `existing.length === 0` and race on INSERT.
+ * The generated `id` is only used if no row exists; on conflict we read
+ * back the canonical id from the surviving row.
+ */
+export async function upsertUser(db, input) {
+    const email = normalizeEmail(input.email);
+    const now = new Date();
+    const id = `usr_${randomUUID()}`;
+    await db
+        .insert(dashboardUsers)
+        .values({
+        id,
+        email,
+        name: input.name,
+        workosUserId: input.workosUserId,
+        createdAt: now,
+        lastLoginAt: now,
+    })
+        .onConflictDoUpdate({
+        target: dashboardUsers.email,
+        set: {
+            name: input.name,
+            workosUserId: input.workosUserId,
+            lastLoginAt: now,
+        },
+    });
+    // Read back the canonical id — it may be a pre-existing row's id, not
+    // the one we just generated above.
+    const rows = await db
+        .select()
+        .from(dashboardUsers)
+        .where(eq(dashboardUsers.email, email))
+        .limit(1);
+    return rows[0].id;
+}
+/**
+ * Look up a dashboard user by id. Returns `null` when not found.
+ */
+export async function getUserById(db, id) {
+    const rows = await db
+        .select()
+        .from(dashboardUsers)
+        .where(eq(dashboardUsers.id, id))
+        .limit(1);
+    if (rows.length === 0)
+        return null;
+    const row = rows[0];
+    return {
+        id: row.id,
+        email: row.email,
+        name: row.name ?? null,
+        workosUserId: row.workosUserId ?? null,
+        createdAt: row.createdAt,
+        lastLoginAt: row.lastLoginAt ?? null,
+        role: (row.role ?? "viewer"),
+    };
+}
+//# sourceMappingURL=user-store.js.map

package/dist/auth/user-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-store.js","sourceRoot":"","sources":["../../src/auth/user-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEjC,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAmBjD,SAAS,cAAc,CAAC,KAAa;IACnC,OAAO,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;AACpC,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAC9B,EAAS,EACT,KAAsB;IAEtB,MAAM,KAAK,GAAG,cAAc,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC1C,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;IACvB,MAAM,EAAE,GAAG,OAAO,UAAU,EAAE,EAAE,CAAC;IAEjC,MAAM,EAAE;SACL,MAAM,CAAC,cAAc,CAAC;SACtB,MAAM,CAAC;QACN,EAAE;QACF,KAAK;QACL,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,YAAY,EAAE,KAAK,CAAC,YAAY;QAChC,SAAS,EAAE,GAAG;QACd,WAAW,EAAE,GAAG;KACjB,CAAC;SACD,kBAAkB,CAAC;QAClB,MAAM,EAAE,cAAc,CAAC,KAAK;QAC5B,GAAG,EAAE;YACH,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,WAAW,EAAE,GAAG;SACjB;KACF,CAAC,CAAC;IAEL,sEAAsE;IACtE,mCAAmC;IACnC,MAAM,IAAI,GAAG,MAAM,EAAE;SAClB,MAAM,EAAE;SACR,IAAI,CAAC,cAAc,CAAC;SACpB,KAAK,CAAC,EAAE,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;SACtC,KAAK,CAAC,CAAC,CAAC,CAAC;IACZ,OAAO,IAAI,CAAC,CAAC,CAAE,CAAC,EAAE,CAAC;AACrB,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,EAAS,EACT,EAAU;IAEV,MAAM,IAAI,GAAG,MAAM,EAAE;SAClB,MAAM,EAAE;SACR,IAAI,CAAC,cAAc,CAAC;SACpB,KAAK,CAAC,EAAE,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;SAChC,KAAK,CAAC,CAAC,CAAC,CAAC;IACZ,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACnC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAE,CAAC;IACrB,OAAO;QACL,EAAE,EAAE,GAAG,CAAC,EAAE;QACV,KAAK,EAAE,GAAG,CAAC,KAAK;QAChB,IAAI,EAAE,GAAG,CAAC,IAAI,IAAI,IAAI;QACtB,YAAY,EAAE,GAAG,CAAC,YAAY,IAAI,IAAI;QACtC,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,WAAW,EAAE,GAAG,CAAC,WAAW,IAAI,IAAI;QACpC,IAAI,EAAE,CAAE,GAAgC,CAAC,IAAI,IAAI,QAAQ,CAAS;KACnE,CAAC;AACJ,CAAC"}

package/dist/auth/workos-client.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Thin interface over @workos-inc/node so tests can inject a stub
+ * without importing the SDK or hitting the network.
+ */
+export interface WorkosAuthorizeArgs {
+    clientId: string;
+    redirectUri: string;
+    state: string;
+}
+export interface WorkosAuthenticateArgs {
+    clientId: string;
+    code: string;
+}
+export interface WorkosUserProfile {
+    id: string;
+    email: string;
+    firstName: string | null;
+    lastName: string | null;
+}
+export interface WorkosAuthenticateResult {
+    user: WorkosUserProfile;
+}
+export interface WorkosClient {
+    getAuthorizationUrl(args: WorkosAuthorizeArgs): Promise<string>;
+    authenticateWithCode(args: WorkosAuthenticateArgs): Promise<WorkosAuthenticateResult>;
+}
+/**
+ * Default WorkOS client. Lazily instantiates the SDK on first use so test
+ * environments that never call this never need the SDK installed.
+ *
+ * NOTE: The singleton cache is not keyed on apiKey. If the API key is
+ * rotated, the process must be restarted to pick up the new key. The cache
+ * is also coupled to the license cache: if a future change introduces
+ * in-process license refresh (see `_resetLicenseCache`), call
+ * `_resetWorkosClient()` too so the next call re-evaluates the gate.
+ *
+ * Throws `LicenseRequiredError` if the `sso` feature is not licensed. This is
+ * a defensive library-boundary gate: even though dashboard wiring already
+ * skips SSO mounting in OSS mode, any direct caller of this function (CLI
+ * bootstrap, future routes, third-party integrations) cannot accidentally
+ * load the WorkOS SDK without a license.
+ */
+export declare function getDefaultWorkosClient(apiKey: string): Promise<WorkosClient>;
+/** Test-only: reset the cached client. */
+export declare function _resetWorkosClient(): void;
+//# sourceMappingURL=workos-client.d.ts.map

package/dist/auth/workos-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workos-client.d.ts","sourceRoot":"","sources":["../../src/auth/workos-client.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,iBAAiB,CAAC;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,mBAAmB,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAChE,oBAAoB,CAAC,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;CACvF;AAID;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CA0ClF;AAED,0CAA0C;AAC1C,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}

package/dist/auth/workos-client.js

@@ -0,0 +1,66 @@
+import { checkLicense, LicenseRequiredError } from "../license.js";
+import { createLogger } from "../logger.js";
+const log = createLogger({ component: "auth.workos" });
+let cached = null;
+/**
+ * Default WorkOS client. Lazily instantiates the SDK on first use so test
+ * environments that never call this never need the SDK installed.
+ *
+ * NOTE: The singleton cache is not keyed on apiKey. If the API key is
+ * rotated, the process must be restarted to pick up the new key. The cache
+ * is also coupled to the license cache: if a future change introduces
+ * in-process license refresh (see `_resetLicenseCache`), call
+ * `_resetWorkosClient()` too so the next call re-evaluates the gate.
+ *
+ * Throws `LicenseRequiredError` if the `sso` feature is not licensed. This is
+ * a defensive library-boundary gate: even though dashboard wiring already
+ * skips SSO mounting in OSS mode, any direct caller of this function (CLI
+ * bootstrap, future routes, third-party integrations) cannot accidentally
+ * load the WorkOS SDK without a license.
+ */
+export async function getDefaultWorkosClient(apiKey) {
+    const status = checkLicense();
+    if (!status.features.has("sso")) {
+        log.warn({ feature: "sso", tier: status.tier }, "getDefaultWorkosClient called without an enterprise license — refusing to load WorkOS SDK");
+        throw new LicenseRequiredError("sso", status.tier);
+    }
+    if (cached)
+        return cached;
+    // Dynamic import so the dep is loaded only when actually used.
+    // The SDK lives in @urateam/dashboard (the only package that activates SSO),
+    // so core does not declare it as a dependency. Suppress the missing-types
+    // error here — the dashboard provides the resolved module at runtime.
+    // @ts-expect-error — @workos-inc/node is an optional runtime dep provided by dashboard
+    const { WorkOS } = await import("@workos-inc/node");
+    const workos = new WorkOS(apiKey);
+    cached = {
+        async getAuthorizationUrl(args) {
+            return workos.userManagement.getAuthorizationUrl({
+                clientId: args.clientId,
+                redirectUri: args.redirectUri,
+                state: args.state,
+                provider: "authkit",
+            });
+        },
+        async authenticateWithCode(args) {
+            const result = await workos.userManagement.authenticateWithCode({
+                clientId: args.clientId,
+                code: args.code,
+            });
+            return {
+                user: {
+                    id: result.user.id,
+                    email: result.user.email,
+                    firstName: result.user.firstName ?? null,
+                    lastName: result.user.lastName ?? null,
+                },
+            };
+        },
+    };
+    return cached;
+}
+/** Test-only: reset the cached client. */
+export function _resetWorkosClient() {
+    cached = null;
+}
+//# sourceMappingURL=workos-client.js.map

package/dist/auth/workos-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workos-client.js","sourceRoot":"","sources":["../../src/auth/workos-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,SAAS,EAAE,aAAa,EAAE,CAAC,CAAC;AAiCvD,IAAI,MAAM,GAAwB,IAAI,CAAC;AAEvC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAAC,MAAc;IACzD,MAAM,MAAM,GAAG,YAAY,EAAE,CAAC;IAC9B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QAChC,GAAG,CAAC,IAAI,CACN,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,EACrC,2FAA2F,CAC5F,CAAC;QACF,MAAM,IAAI,oBAAoB,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;IACrD,CAAC;IACD,IAAI,MAAM;QAAE,OAAO,MAAM,CAAC;IAC1B,+DAA+D;IAC/D,6EAA6E;IAC7E,0EAA0E;IAC1E,sEAAsE;IACtE,uFAAuF;IACvF,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAAC;IACpD,MAAM,MAAM,GAAQ,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC;IACvC,MAAM,GAAG;QACP,KAAK,CAAC,mBAAmB,CAAC,IAAI;YAC5B,OAAO,MAAM,CAAC,cAAc,CAAC,mBAAmB,CAAC;gBAC/C,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,QAAQ,EAAE,SAAS;aACpB,CAAC,CAAC;QACL,CAAC;QACD,KAAK,CAAC,oBAAoB,CAAC,IAAI;YAC7B,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,cAAc,CAAC,oBAAoB,CAAC;gBAC9D,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,IAAI,EAAE,IAAI,CAAC,IAAI;aAChB,CAAC,CAAC;YACH,OAAO;gBACL,IAAI,EAAE;oBACJ,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE;oBAClB,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK;oBACxB,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI;oBACxC,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI;iBACvC;aACF,CAAC;QACJ,CAAC;KACF,CAAC;IACF,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,0CAA0C;AAC1C,MAAM,UAAU,kBAAkB;IAChC,MAAM,GAAG,IAAI,CAAC;AAChB,CAAC"}

package/dist/cost/aggregate.d.ts

@@ -0,0 +1,49 @@
+import type { AnyDb } from "../db/client.js";
+import type { AggregateResult } from "./types.js";
+export declare function normalizeTeamId(id: string | null | undefined): {
+    key: string;
+    label: string;
+};
+export interface AggregateFilters {
+    from: Date;
+    to: Date;
+}
+interface CostConfig {
+    costs?: {
+        hourlyEngRate?: number;
+        modelPricing?: Record<string, {
+            inputPerMillion: number;
+            outputPerMillion: number;
+        }>;
+        timeSavedPerPrDefault?: number;
+    };
+    pipelineConfigs?: Record<string, any>;
+}
+export declare function aggregateAll(db: AnyDb, filters: AggregateFilters, config: CostConfig, opts?: {
+    maxRuns?: number;
+}): Promise<AggregateResult>;
+/** Snap a Date down to the start of its UTC day (00:00:00.000 UTC). */
+export declare function snapToUtcDayStart(d: Date): Date;
+/**
+ * Hybrid aggregate: uses pre-computed rollup rows for whole UTC days before
+ * today, and live `aggregateAll` for today's partial data. The two halves are
+ * summed into a single `AggregateResult`.
+ *
+ * When `opts.enableRollups` is false (the default for arbitrary custom
+ * windows), falls back to pure live aggregation.
+ *
+ * IMPORTANT: `filters.from` must be at a UTC day boundary (00:00 UTC) for
+ * rollup-backed reads to be exact — the rollup table stores per-day totals.
+ * For preset windows (7d/30d/90d/365d) the caller is expected to snap `from`
+ * via `snapToUtcDayStart`. For non-aligned `from`, this function still routes
+ * through rollups but will slightly over-count by including the full first
+ * UTC day — acceptable for preset usage, unsuitable for arbitrary windows
+ * (hence the opt-in `enableRollups` flag).
+ */
+export declare function aggregateHybrid(db: AnyDb, filters: AggregateFilters, config: CostConfig, opts?: {
+    maxRuns?: number;
+    now?: Date;
+    enableRollups?: boolean;
+}): Promise<AggregateResult>;
+export {};
+//# sourceMappingURL=aggregate.d.ts.map

package/dist/cost/aggregate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../src/cost/aggregate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAK7C,OAAO,KAAK,EAAE,eAAe,EAAuC,MAAM,YAAY,CAAC;AAmBvF,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAK7F;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,IAAI,CAAC;IACX,EAAE,EAAE,IAAI,CAAC;CACV;AAED,UAAU,UAAU;IAClB,KAAK,CAAC,EAAE;QACN,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,eAAe,EAAE,MAAM,CAAC;YAAC,gBAAgB,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QACrF,qBAAqB,CAAC,EAAE,MAAM,CAAC;KAChC,CAAC;IACF,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACvC;AAeD,wBAAsB,YAAY,CAChC,EAAE,EAAE,KAAK,EACT,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,UAAU,EAClB,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAC9B,OAAO,CAAC,eAAe,CAAC,CAiI1B;AAED,uEAAuE;AACvE,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAE/C;AAyID;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,CACnC,EAAE,EAAE,KAAK,EACT,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,UAAU,EAClB,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,IAAI,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAO,GACnE,OAAO,CAAC,eAAe,CAAC,CAmF1B"}

package/dist/cost/aggregate.js

@@ -0,0 +1,364 @@
+import { and, gte, lt, inArray } from "drizzle-orm";
+import { pipelineRuns, stageRuns, costRollupsDaily } from "../db/schema.js";
+import { computeRunCost } from "./per-run.js";
+import { createLogger } from "../logger.js";
+import { isFeatureLicensed } from "../license.js";
+const log = createLogger({ component: "cost.aggregate" });
+function emptyAggregateResult(filters) {
+    return {
+        summary: {
+            window: { from: filters.from, to: filters.to },
+            runs: 0, prsMerged: 0, inputTokens: 0, outputTokens: 0,
+            dollars: 0, timeSavedHours: 0, roiMultiplier: 0,
+        },
+        byTeam: [], byRepo: [], byPipeline: [], byDay: [],
+    };
+}
+const DEFAULT_MAX_RUNS = 10_000;
+const UNASSIGNED_TEAM = "(unassigned)";
+export function normalizeTeamId(id) {
+    if (id === null || id === undefined || id === "") {
+        return { key: "team:unassigned", label: UNASSIGNED_TEAM };
+    }
+    return { key: `team:${id}`, label: id };
+}
+function emptyBucket(key, label) {
+    return {
+        key, label, runs: 0, prsMerged: 0,
+        inputTokens: 0, outputTokens: 0,
+        dollars: 0, timeSavedHours: 0, roiMultiplier: 0,
+    };
+}
+function finalizeRoi(row, hourlyRate) {
+    if (row.dollars === 0)
+        return row.timeSavedHours > 0 ? Infinity : 0;
+    return (row.timeSavedHours * hourlyRate) / row.dollars;
+}
+export async function aggregateAll(db, filters, config, opts = {}) {
+    if (!isFeatureLicensed("cost-roi")) {
+        log.warn({ feature: "cost-roi" }, "aggregateAll called without an enterprise license — returning empty result");
+        return emptyAggregateResult(filters);
+    }
+    const hourlyRate = config.costs?.hourlyEngRate ?? 50;
+    const maxRuns = opts.maxRuns ?? DEFAULT_MAX_RUNS;
+    const runs = await db.select().from(pipelineRuns).where(and(gte(pipelineRuns.completedAt, filters.from), 
+    // half-open [from, to) — matches rollup.ts convention and avoids double-counting at the boundary
+    lt(pipelineRuns.completedAt, filters.to)));
+    let truncated = false;
+    if (runs.length > maxRuns) {
+        log.warn({ runs: runs.length, maxRuns, from: filters.from, to: filters.to }, "aggregateAll: runs exceed cap, truncating to most recent");
+        // Sort by completedAt DESC (nulls last) and keep only the most recent `maxRuns`.
+        runs.sort((a, b) => {
+            const ta = a.completedAt ? new Date(a.completedAt).getTime() : 0;
+            const tb = b.completedAt ? new Date(b.completedAt).getTime() : 0;
+            return tb - ta;
+        });
+        runs.splice(maxRuns);
+        truncated = true;
+    }
+    if (runs.length === 0) {
+        return {
+            summary: {
+                window: { from: filters.from, to: filters.to },
+                runs: 0, prsMerged: 0, inputTokens: 0, outputTokens: 0,
+                dollars: 0, timeSavedHours: 0, roiMultiplier: 0,
+            },
+            byTeam: [], byRepo: [], byPipeline: [], byDay: [],
+        };
+    }
+    const runIds = runs.map((r) => r.id);
+    const stages = await db.select().from(stageRuns).where(inArray(stageRuns.pipelineRunId, runIds));
+    const stagesByRun = new Map();
+    for (const s of stages) {
+        const arr = stagesByRun.get(s.pipelineRunId) ?? [];
+        arr.push(s);
+        stagesByRun.set(s.pipelineRunId, arr);
+    }
+    const summary = {
+        window: { from: filters.from, to: filters.to },
+        runs: 0, prsMerged: 0, inputTokens: 0, outputTokens: 0,
+        dollars: 0, timeSavedHours: 0, roiMultiplier: 0,
+        ...(truncated ? { truncated: true } : {}),
+    };
+    const byTeam = new Map();
+    const byRepo = new Map();
+    const byPipeline = new Map();
+    const byDay = new Map();
+    for (const run of runs) {
+        const runStages = stagesByRun.get(run.id) ?? [];
+        const cost = computeRunCost(run, runStages, config);
+        const isMergedPr = run.status === "completed" && run.runType !== "review-feedback";
+        summary.runs += 1;
+        summary.inputTokens += cost.inputTokens;
+        summary.outputTokens += cost.outputTokens;
+        summary.dollars += cost.dollars;
+        summary.timeSavedHours += cost.timeSavedHours;
+        if (isMergedPr)
+            summary.prsMerged += 1;
+        // completedAt is guaranteed non-null here — the WHERE clause above filters
+        // on `gte(completedAt, from)` and `lt(completedAt, to)`, which excludes
+        // rows where completedAt IS NULL (SQL NULL comparisons are falsy).
+        const dateStr = new Date(run.completedAt).toISOString().slice(0, 10);
+        let dr = byDay.get(dateStr);
+        if (!dr) {
+            dr = { date: dateStr, runs: 0, prsMerged: 0, dollars: 0, timeSavedHours: 0 };
+            byDay.set(dateStr, dr);
+        }
+        dr.runs += 1;
+        dr.dollars += cost.dollars;
+        dr.timeSavedHours += cost.timeSavedHours;
+        if (isMergedPr)
+            dr.prsMerged += 1;
+        const { key: teamKey, label: teamLabel } = normalizeTeamId(run.linearTeamId);
+        if (!byTeam.has(teamKey))
+            byTeam.set(teamKey, emptyBucket(teamKey, teamLabel));
+        const tb = byTeam.get(teamKey);
+        tb.runs += 1;
+        tb.inputTokens += cost.inputTokens;
+        tb.outputTokens += cost.outputTokens;
+        tb.dollars += cost.dollars;
+        tb.timeSavedHours += cost.timeSavedHours;
+        if (isMergedPr)
+            tb.prsMerged += 1;
+        const repoKey = `repo:${run.repoUrl}`;
+        if (!byRepo.has(repoKey))
+            byRepo.set(repoKey, emptyBucket(repoKey, run.repoUrl));
+        const rb = byRepo.get(repoKey);
+        rb.runs += 1;
+        rb.inputTokens += cost.inputTokens;
+        rb.outputTokens += cost.outputTokens;
+        rb.dollars += cost.dollars;
+        rb.timeSavedHours += cost.timeSavedHours;
+        if (isMergedPr)
+            rb.prsMerged += 1;
+        const pipelineKey = `pipeline:${run.pipelineKey}`;
+        if (!byPipeline.has(pipelineKey))
+            byPipeline.set(pipelineKey, emptyBucket(pipelineKey, run.pipelineKey));
+        const pb = byPipeline.get(pipelineKey);
+        pb.runs += 1;
+        pb.inputTokens += cost.inputTokens;
+        pb.outputTokens += cost.outputTokens;
+        pb.dollars += cost.dollars;
+        pb.timeSavedHours += cost.timeSavedHours;
+        if (isMergedPr)
+            pb.prsMerged += 1;
+    }
+    summary.roiMultiplier = finalizeRoi(summary, hourlyRate);
+    const sort = (a, b) => b.dollars - a.dollars;
+    const finalize = (rows) => {
+        for (const r of rows)
+            r.roiMultiplier = finalizeRoi(r, hourlyRate);
+        return rows.sort(sort);
+    };
+    return {
+        summary,
+        byTeam: finalize(Array.from(byTeam.values())),
+        byRepo: finalize(Array.from(byRepo.values())),
+        byPipeline: finalize(Array.from(byPipeline.values())),
+        byDay: Array.from(byDay.values()).sort((a, b) => a.date.localeCompare(b.date)),
+    };
+}
+/** Snap a Date down to the start of its UTC day (00:00:00.000 UTC). */
+export function snapToUtcDayStart(d) {
+    return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
+}
+function utcDateStr(d) {
+    return d.toISOString().slice(0, 10);
+}
+/**
+ * Aggregate pre-computed rollup rows for UTC dates in [fromDate, toDate).
+ * Both bounds are YYYY-MM-DD strings. Returns an AggregateResult whose
+ * window.from/to reflect the caller-supplied Date objects (not the date
+ * strings), so the summary is consistent with the caller's framing.
+ */
+async function aggregateFromRollups(db, fromDate, toDate, window, hourlyRate) {
+    // Half-open [fromDate, toDate) — use gte(date) + lt(date) on the date string.
+    const rows = await db.select().from(costRollupsDaily).where(and(gte(costRollupsDaily.date, fromDate), lt(costRollupsDaily.date, toDate)));
+    const summary = {
+        window,
+        runs: 0, prsMerged: 0, inputTokens: 0, outputTokens: 0,
+        dollars: 0, timeSavedHours: 0, roiMultiplier: 0,
+    };
+    const byTeam = new Map();
+    const byRepo = new Map();
+    const byPipeline = new Map();
+    const byDay = new Map();
+    for (const r of rows) {
+        summary.runs += r.runs;
+        summary.prsMerged += r.prsMerged;
+        summary.inputTokens += r.inputTokens;
+        summary.outputTokens += r.outputTokens;
+        summary.dollars += r.dollars;
+        summary.timeSavedHours += r.timeSavedHours;
+        // Rollup rows are already bucketed by date × pipeline × team × repo,
+        // so multiple rollup rows can share the same date.
+        let dr = byDay.get(r.date);
+        if (!dr) {
+            dr = { date: r.date, runs: 0, prsMerged: 0, dollars: 0, timeSavedHours: 0 };
+            byDay.set(r.date, dr);
+        }
+        dr.runs += r.runs;
+        dr.prsMerged += r.prsMerged;
+        dr.dollars += r.dollars;
+        dr.timeSavedHours += r.timeSavedHours;
+        // rollup stores linearTeamId as "" sentinel for unassigned (see rollup.ts)
+        const teamId = r.linearTeamId === "" ? null : r.linearTeamId;
+        const { key: teamKey, label: teamLabel } = normalizeTeamId(teamId);
+        if (!byTeam.has(teamKey))
+            byTeam.set(teamKey, emptyBucket(teamKey, teamLabel));
+        const tb = byTeam.get(teamKey);
+        tb.runs += r.runs;
+        tb.prsMerged += r.prsMerged;
+        tb.inputTokens += r.inputTokens;
+        tb.outputTokens += r.outputTokens;
+        tb.dollars += r.dollars;
+        tb.timeSavedHours += r.timeSavedHours;
+        const repoKey = `repo:${r.repoUrl}`;
+        if (!byRepo.has(repoKey))
+            byRepo.set(repoKey, emptyBucket(repoKey, r.repoUrl));
+        const rb = byRepo.get(repoKey);
+        rb.runs += r.runs;
+        rb.prsMerged += r.prsMerged;
+        rb.inputTokens += r.inputTokens;
+        rb.outputTokens += r.outputTokens;
+        rb.dollars += r.dollars;
+        rb.timeSavedHours += r.timeSavedHours;
+        const pipelineKey = `pipeline:${r.pipelineKey}`;
+        if (!byPipeline.has(pipelineKey))
+            byPipeline.set(pipelineKey, emptyBucket(pipelineKey, r.pipelineKey));
+        const pb = byPipeline.get(pipelineKey);
+        pb.runs += r.runs;
+        pb.prsMerged += r.prsMerged;
+        pb.inputTokens += r.inputTokens;
+        pb.outputTokens += r.outputTokens;
+        pb.dollars += r.dollars;
+        pb.timeSavedHours += r.timeSavedHours;
+    }
+    summary.roiMultiplier = finalizeRoi(summary, hourlyRate);
+    const sort = (a, b) => b.dollars - a.dollars;
+    const finalize = (rows) => {
+        for (const r of rows)
+            r.roiMultiplier = finalizeRoi(r, hourlyRate);
+        return rows.sort(sort);
+    };
+    return {
+        summary,
+        byTeam: finalize(Array.from(byTeam.values())),
+        byRepo: finalize(Array.from(byRepo.values())),
+        byPipeline: finalize(Array.from(byPipeline.values())),
+        byDay: Array.from(byDay.values()).sort((a, b) => a.date.localeCompare(b.date)),
+    };
+}
+function mergeDailyRows(a, b) {
+    const byDate = new Map();
+    for (const row of [...a, ...b]) {
+        const existing = byDate.get(row.date);
+        if (!existing) {
+            byDate.set(row.date, { ...row });
+        }
+        else {
+            existing.runs += row.runs;
+            existing.prsMerged += row.prsMerged;
+            existing.dollars += row.dollars;
+            existing.timeSavedHours += row.timeSavedHours;
+        }
+    }
+    return Array.from(byDate.values()).sort((x, y) => x.date.localeCompare(y.date));
+}
+function mergeBreakdowns(a, b, hourlyRate) {
+    const byKey = new Map();
+    for (const row of [...a, ...b]) {
+        const existing = byKey.get(row.key);
+        if (!existing) {
+            byKey.set(row.key, { ...row });
+        }
+        else {
+            existing.runs += row.runs;
+            existing.prsMerged += row.prsMerged;
+            existing.inputTokens += row.inputTokens;
+            existing.outputTokens += row.outputTokens;
+            existing.dollars += row.dollars;
+            existing.timeSavedHours += row.timeSavedHours;
+        }
+    }
+    const merged = Array.from(byKey.values());
+    for (const r of merged)
+        r.roiMultiplier = finalizeRoi(r, hourlyRate);
+    return merged.sort((x, y) => y.dollars - x.dollars);
+}
+/**
+ * Hybrid aggregate: uses pre-computed rollup rows for whole UTC days before
+ * today, and live `aggregateAll` for today's partial data. The two halves are
+ * summed into a single `AggregateResult`.
+ *
+ * When `opts.enableRollups` is false (the default for arbitrary custom
+ * windows), falls back to pure live aggregation.
+ *
+ * IMPORTANT: `filters.from` must be at a UTC day boundary (00:00 UTC) for
+ * rollup-backed reads to be exact — the rollup table stores per-day totals.
+ * For preset windows (7d/30d/90d/365d) the caller is expected to snap `from`
+ * via `snapToUtcDayStart`. For non-aligned `from`, this function still routes
+ * through rollups but will slightly over-count by including the full first
+ * UTC day — acceptable for preset usage, unsuitable for arbitrary windows
+ * (hence the opt-in `enableRollups` flag).
+ */
+export async function aggregateHybrid(db, filters, config, opts = {}) {
+    if (!isFeatureLicensed("cost-roi")) {
+        log.warn({ feature: "cost-roi" }, "aggregateHybrid called without an enterprise license — returning empty result");
+        return emptyAggregateResult(filters);
+    }
+    const enableRollups = opts.enableRollups ?? false;
+    if (!enableRollups) {
+        return aggregateAll(db, filters, config, opts);
+    }
+    const hourlyRate = config.costs?.hourlyEngRate ?? 50;
+    const now = opts.now ?? new Date();
+    const todayUtcStart = snapToUtcDayStart(now);
+    // If the window doesn't span any completed UTC days, fall through to pure live.
+    if (filters.from >= todayUtcStart) {
+        return aggregateAll(db, filters, config, opts);
+    }
+    // Compute the rollup window (whole UTC days) and the live remainder (today).
+    const rollupEndDateStr = utcDateStr(todayUtcStart);
+    const rollupFromDateStr = utcDateStr(filters.from);
+    // If the user's window ends before today's UTC midnight, rollup covers the
+    // full window and there's no live component.
+    const rollupOnlyCutoff = filters.to <= todayUtcStart ? filters.to : todayUtcStart;
+    const rollupToDateStr = utcDateStr(rollupOnlyCutoff);
+    const rollupPart = await aggregateFromRollups(db, rollupFromDateStr, 
+    // Upper bound is exclusive (lt on date string). `rollupEndDateStr` is
+    // today's date, so lt excludes today and includes through yesterday.
+    // When the window ends before today (rollup-only path), the upper bound
+    // is the window's `to` date so lt(date, windowTo) includes everything
+    // strictly before windowTo's UTC date.
+    rollupOnlyCutoff < todayUtcStart ? rollupToDateStr : rollupEndDateStr, { from: filters.from, to: filters.to }, hourlyRate);
+    // If the window ends before today's midnight, we're done.
+    if (filters.to <= todayUtcStart) {
+        log.debug({ from: rollupFromDateStr, to: rollupToDateStr }, "aggregateHybrid: rollup-only path");
+        return rollupPart;
+    }
+    // Live query for today's partial data [todayUtcStart, filters.to).
+    const livePart = await aggregateAll(db, { from: todayUtcStart, to: filters.to }, config, opts);
+    log.debug({ rollupDays: rollupFromDateStr + "..." + rollupEndDateStr, liveFrom: todayUtcStart.toISOString() }, "aggregateHybrid: rollup + live merge");
+    // Merge summary
+    const mergedSummary = {
+        window: { from: filters.from, to: filters.to },
+        runs: rollupPart.summary.runs + livePart.summary.runs,
+        prsMerged: rollupPart.summary.prsMerged + livePart.summary.prsMerged,
+        inputTokens: rollupPart.summary.inputTokens + livePart.summary.inputTokens,
+        outputTokens: rollupPart.summary.outputTokens + livePart.summary.outputTokens,
+        dollars: rollupPart.summary.dollars + livePart.summary.dollars,
+        timeSavedHours: rollupPart.summary.timeSavedHours + livePart.summary.timeSavedHours,
+        roiMultiplier: 0,
+        ...(livePart.summary.truncated ? { truncated: true } : {}),
+    };
+    mergedSummary.roiMultiplier = finalizeRoi(mergedSummary, hourlyRate);
+    return {
+        summary: mergedSummary,
+        byTeam: mergeBreakdowns(rollupPart.byTeam, livePart.byTeam, hourlyRate),
+        byRepo: mergeBreakdowns(rollupPart.byRepo, livePart.byRepo, hourlyRate),
+        byPipeline: mergeBreakdowns(rollupPart.byPipeline, livePart.byPipeline, hourlyRate),
+        byDay: mergeDailyRows(rollupPart.byDay, livePart.byDay),
+    };
+}
+//# sourceMappingURL=aggregate.js.map