@reprova/sdk 0.5.0 → 0.6.0

package/dist/cjs/kysely.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKyselyPlugin = createKyselyPlugin;
+const context_js_1 = require("./context.js");
+const OP_BY_KIND = {
+    SelectQueryNode: 'select',
+    InsertQueryNode: 'insert',
+    UpdateQueryNode: 'update',
+    DeleteQueryNode: 'delete',
+    MergeQueryNode: 'merge',
+};
+// TableNode → its identifier name; unwraps an AliasNode (`from('t as x')`).
+function tableName(node) {
+    const n = node;
+    if (!n || typeof n !== 'object')
+        return undefined;
+    if (n.kind === 'AliasNode')
+        return tableName(n.node);
+    if (n.kind === 'TableNode') {
+        const table = n.table;
+        return table?.identifier?.name;
+    }
+    return undefined;
+}
+// The operation's principal table, read from the op-specific field.
+function primaryTable(node) {
+    switch (node.kind) {
+        case 'SelectQueryNode':
+        case 'DeleteQueryNode': {
+            const from = node.from;
+            return tableName(from?.froms?.[0]);
+        }
+        case 'InsertQueryNode':
+            return tableName(node.into);
+        case 'UpdateQueryNode':
+            return tableName(node.table);
+        default:
+            return undefined;
+    }
+}
+// Every table referenced anywhere in the query (joins, subqueries, CTEs, …),
+// in first-seen order. A bounded deep-walk — instrumentation must not blow the
+// stack or hang on a pathological tree.
+function collectTables(root) {
+    const found = [];
+    const seen = new Set();
+    const stack = [root];
+    let budget = 5000;
+    while (stack.length && budget-- > 0) {
+        const cur = stack.pop();
+        if (!cur || typeof cur !== 'object')
+            continue;
+        const name = tableName(cur);
+        if (name && !seen.has(name)) {
+            seen.add(name);
+            found.push(name);
+        }
+        for (const v of Object.values(cur)) {
+            if (v && typeof v === 'object')
+                stack.push(v);
+        }
+    }
+    return found;
+}
+// Column NAMES referenced inside a WhereNode subtree — never values.
+function whereColumns(whereNode) {
+    const cols = new Set();
+    const stack = [whereNode];
+    let budget = 5000;
+    while (stack.length && budget-- > 0) {
+        const cur = stack.pop();
+        if (!cur || typeof cur !== 'object')
+            continue;
+        const n = cur;
+        if (n.kind === 'ColumnNode') {
+            const col = n.column;
+            if (col?.name)
+                cols.add(col.name);
+        }
+        for (const v of Object.values(n)) {
+            if (v && typeof v === 'object')
+                stack.push(v);
+        }
+    }
+    return [...cols].sort();
+}
+function extractPks(rows, pkCols) {
+    if (pkCols.length === 0)
+        return [];
+    // A set: a join can return the same primary-table row many times, but the
+    // footprint records which DISTINCT rows were touched.
+    const seen = new Set();
+    const pks = [];
+    for (const row of rows) {
+        const vals = pkCols.map((c) => row[c]);
+        if (vals.some((v) => v === undefined))
+            continue; // column not selected — can't form a PK
+        const pk = vals.map((v) => String(v)).join(':');
+        if (!seen.has(pk)) {
+            seen.add(pk);
+            pks.push(pk);
+        }
+    }
+    return pks;
+}
+// Creates the Reprova Kysely footprint plugin.
+// Usage: new Kysely({ dialect, plugins: [createKyselyPlugin()] })
+function createKyselyPlugin(opts = {}) {
+    const primaryKey = opts.primaryKey ?? (() => ['id']);
+    const captureWhereShape = opts.captureWhereShape !== false;
+    // Keyed by the queryId OBJECT shared across both hooks; a compiled-but-never-
+    // executed query is GC'd without leaking.
+    const pending = new WeakMap();
+    return {
+        transformQuery(args) {
+            try {
+                const node = args.node;
+                const op = OP_BY_KIND[node.kind];
+                if (op) {
+                    const whereShape = captureWhereShape && node.where
+                        ? whereColumns(node.where).join(',') || undefined
+                        : undefined;
+                    pending.set(args.queryId, {
+                        op,
+                        primary: primaryTable(node),
+                        tables: collectTables(node),
+                        whereShape,
+                    });
+                }
+            }
+            catch {
+                // A footprint failure must never alter the query — fall through.
+            }
+            return args.node;
+        },
+        async transformResult(args) {
+            try {
+                const meta = pending.get(args.queryId);
+                if (meta) {
+                    pending.delete(args.queryId);
+                    const ctx = context_js_1.contextStorage.getStore();
+                    if (ctx) {
+                        const result = args.result;
+                        const rows = result.rows ?? [];
+                        const affected = result.numAffectedRows != null ? Number(result.numAffectedRows) : undefined;
+                        const count = rows.length || affected || 0;
+                        const primary = meta.primary ?? '$unknown';
+                        const entry = {
+                            model: primary,
+                            op: meta.op,
+                            pks: extractPks(rows, primaryKey(primary)),
+                            where_shape: meta.whereShape,
+                            count,
+                            note: count === 0 ? 'returned 0 rows' : undefined,
+                            resolved: true,
+                        };
+                        ctx.footprint.push(entry);
+                        // Joined / subquery tables: recorded so the extractor knows they
+                        // were touched, but without PKs (result columns can't be reliably
+                        // attributed across a join).
+                        for (const t of meta.tables) {
+                            if (t === primary)
+                                continue;
+                            ctx.footprint.push({ model: t, op: meta.op, pks: [], count: 0, note: 'referenced (join/subquery)', resolved: true });
+                        }
+                    }
+                }
+            }
+            catch {
+                // Never break the result pipeline over a footprint error.
+            }
+            return args.result;
+        },
+    };
+}

package/dist/cjs/legacyPrisma.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instrumentLegacyPrismaClient = instrumentLegacyPrismaClient;
+const context_js_1 = require("./context.js");
+const prisma_js_1 = require("./prisma.js");
+// Older Prisma clients have no query-lifecycle hook at all — confirmed live
+// against a real @prisma/client@2.0.0-beta.4 (2020): $extends (introduced
+// 4.16, 2023), $use (Prisma's earlier middleware API, introduced ~2.something
+// and itself later deprecated in favor of $extends), and even $queryRaw are
+// all `undefined` on that client. createPrismaExtension's $allOperations has
+// nothing to attach to on a client like this.
+//
+// What IS there, on every Prisma client generator back to the very first
+// one: a plain per-model delegate object (client.article, client.user, ...)
+// whose CRUD methods (findMany, create, update, ...) are ordinary
+// own-property functions — directly reassignable, the same monkey-patch
+// shape this SDK already uses for TypeORM's QueryRunner.prototype.query and
+// Mongoose's already-compiled models (instrumentAlreadyCompiledModels). This
+// wraps each one directly instead of relying on any official extension
+// point, so footprint capture and every detector built on recordPrismaOperation
+// work identically regardless of how old the installed client is.
+//
+// Also captures DB-rejected writes the same way typeorm.ts does for a
+// TypeORM app: create/update/upsert/delete/updateMany/deleteMany record an
+// `<op>_failed` footprint entry on rejection — column NAMES only (from the
+// call's own `data`/`where` argument keys), never the bound values, per the
+// metadata-only rule. A read failing has no "what would have been written"
+// story, so only write ops get this treatment, matching typeorm.ts's scope.
+const READ_OPS = new Set(['findOne', 'findUnique', 'findUniqueOrThrow', 'findFirst', 'findFirstOrThrow', 'findMany', 'count', 'aggregate', 'groupBy']);
+const WRITE_OPS = new Set(['create', 'createMany', 'update', 'updateMany', 'upsert', 'delete', 'deleteMany']);
+// `findOne` is Prisma's own deprecated alias for `findUnique` (renamed
+// well before $extends existed, still present on clients this old) —
+// normalized before recording so the footprint's `op` field and
+// operationMatchesHook's after_read gating (invariantRules.ts's READ_OPS,
+// which only lists modern names) both see the same vocabulary regardless
+// of which Prisma version actually captured it.
+function normalizeOperation(method) {
+    return method === 'findOne' ? 'findUnique' : method;
+}
+// Reassigns each detected model delegate's own CRUD methods exactly once —
+// re-instrumenting an already-patched delegate (e.g. instrumentPrisma called
+// twice) would double-record every footprint entry.
+const patchedDelegates = new WeakSet();
+function instrumentLegacyPrismaClient(client, opts = {}) {
+    try {
+        const dmmf = opts.dmmf ?? client.dmmf;
+        const hooks = {
+            dmmf,
+            getRules: opts.getRules,
+            inferenceReporter: opts.inferenceReporter,
+            writeCountDriftReporter: opts.writeCountDriftReporter,
+            writeCountBaselinePoller: opts.writeCountBaselinePoller,
+        };
+        const modelNameFor = buildModelNameResolver(dmmf);
+        for (const [key, delegate] of Object.entries(client)) {
+            if (!isModelDelegate(delegate))
+                continue;
+            if (patchedDelegates.has(delegate))
+                continue;
+            patchedDelegates.add(delegate);
+            const modelName = modelNameFor(key);
+            for (const method of Object.keys(delegate)) {
+                if (READ_OPS.has(method)) {
+                    patchReadMethod(delegate, method, modelName, hooks);
+                }
+                else if (WRITE_OPS.has(method)) {
+                    patchWriteMethod(delegate, method, modelName, hooks);
+                }
+            }
+        }
+    }
+    catch {
+        /* never throw from install */
+    }
+}
+function isModelDelegate(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const d = value;
+    return typeof d.findMany === 'function' || typeof d.create === 'function';
+}
+// Prisma's own convention: a model named `Article` gets a delegate property
+// named `article` (first letter lowercased) — true on every version this
+// adapter targets. Falls back to that convention when dmmf isn't available
+// at all; uses the real dmmf model list when it is, so an unconventional
+// name still resolves correctly.
+function buildModelNameResolver(dmmf) {
+    if (!dmmf) {
+        return (key) => key.charAt(0).toUpperCase() + key.slice(1);
+    }
+    const byLowerFirst = new Map();
+    for (const model of dmmf.datamodel.models) {
+        byLowerFirst.set(model.name.charAt(0).toLowerCase() + model.name.slice(1), model.name);
+    }
+    return (key) => byLowerFirst.get(key) ?? key.charAt(0).toUpperCase() + key.slice(1);
+}
+function patchReadMethod(delegate, method, modelName, hooks) {
+    const original = delegate[method];
+    const operation = normalizeOperation(method);
+    delegate[method] = async function (...args) {
+        const result = await original.apply(this, args);
+        const ctx = context_js_1.contextStorage.getStore();
+        if (ctx) {
+            const callArgs = args[0] ?? {};
+            await (0, prisma_js_1.recordPrismaOperation)(ctx, modelName, operation, callArgs, result, hooks);
+        }
+        return result;
+    };
+}
+function patchWriteMethod(delegate, method, modelName, hooks) {
+    const original = delegate[method];
+    delegate[method] = async function (...args) {
+        const callArgs = args[0] ?? {};
+        let result;
+        try {
+            result = await original.apply(this, args);
+        }
+        catch (err) {
+            const ctx = context_js_1.contextStorage.getStore();
+            if (ctx)
+                (0, prisma_js_1.recordFailedWrite)(ctx, modelName, method, callArgs);
+            throw err;
+        }
+        const ctx = context_js_1.contextStorage.getStore();
+        if (ctx) {
+            await (0, prisma_js_1.recordPrismaOperation)(ctx, modelName, method, callArgs, result, hooks);
+        }
+        return result;
+    };
+}

package/dist/cjs/mikroorm.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installMikroOrmSubscriber = installMikroOrmSubscriber;
+const context_js_1 = require("./context.js");
+function pkOf(entity, meta) {
+    const keys = meta?.primaryKeys ?? [];
+    if (!entity || keys.length === 0)
+        return null;
+    const vals = keys.map((k) => entity[k]);
+    if (vals.some((v) => v === undefined || v === null))
+        return null;
+    return vals.map((v) => String(v)).join(':');
+}
+// Find-or-create the (table, op) entry for this request and fold in the PK.
+function recordPk(table, op, pk) {
+    const ctx = context_js_1.contextStorage.getStore();
+    if (!ctx || !table)
+        return;
+    let entry = ctx.footprint.find((f) => f.model === table && f.op === op);
+    if (!entry) {
+        entry = { model: table, op, pks: [], count: 0 };
+        ctx.footprint.push(entry);
+    }
+    if (pk !== null && !entry.pks.includes(pk))
+        entry.pks.push(pk);
+    entry.count = entry.pks.length;
+}
+// Accepts either a MikroORM instance (orm.em.getEventManager()) or an
+// EntityManager directly (em.getEventManager()) — Reprova has no way to
+// know which one a given host app kept a reference to.
+function getEventManager(orm) {
+    const o = orm;
+    if (typeof o.getEventManager === 'function')
+        return o.getEventManager();
+    if (o.em && typeof o.em.getEventManager === 'function')
+        return o.em.getEventManager();
+    return undefined;
+}
+// Installs a footprint subscriber on an initialized MikroORM instance (or
+// EntityManager). Call AFTER MikroORM.init() — the EventManager only
+// exists once the ORM is initialized. Registers a plain object, so the
+// host needs no @Subscriber()-decorated class.
+function installMikroOrmSubscriber(orm) {
+    const subscriber = {
+        onLoad(args) {
+            try {
+                recordPk(args?.meta?.className, 'select', pkOf(args?.entity, args?.meta));
+            }
+            catch { /* never break */ }
+        },
+        afterCreate(args) {
+            try {
+                recordPk(args?.meta?.className, 'insert', pkOf(args?.entity, args?.meta));
+            }
+            catch { /* ignore */ }
+        },
+        afterUpdate(args) {
+            try {
+                recordPk(args?.meta?.className, 'update', pkOf(args?.entity, args?.meta));
+            }
+            catch { /* ignore */ }
+        },
+        afterDelete(args) {
+            try {
+                recordPk(args?.meta?.className, 'delete', pkOf(args?.entity, args?.meta));
+            }
+            catch { /* ignore */ }
+        },
+    };
+    try {
+        getEventManager(orm)?.registerSubscriber(subscriber);
+    }
+    catch { /* never throw from install */ }
+}

package/dist/cjs/mongoSchemaReporter.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoSchemaReporter = void 0;
+const mongoose_js_1 = require("./mongoose.js");
+const httpFetch_js_1 = require("./httpFetch.js");
+// Periodically re-scans a live Mongoose instance's model registry and
+// reports the discovered model->collection map plus every ref: edge found,
+// so the control plane can hand the agent a reference-edge map at
+// plan-build time (MongoDB has no FK catalog for the agent to introspect
+// itself — see mongo_schema.go's handler doc comment). Unlike
+// DistributionDriftReporter (accumulates external .record() deltas since
+// its last flush), this reporter is self-driven: it re-derives the current
+// schema shape itself on each tick and only POSTs when that shape actually
+// changed, since schema shape is near-static and re-sending an unchanged
+// report every tick for the life of a long-running process would be pure
+// waste.
+const WARN_INTERVAL_MS = 60_000;
+const DEFAULT_INTERVAL_MS = 60_000;
+class MongoSchemaReporter {
+    timer = null;
+    lastSentJSON = null;
+    lastWarnAt = 0;
+    endpoint;
+    apiKey;
+    intervalMs;
+    mongooseInstance;
+    constructor(opts) {
+        this.endpoint = opts.endpoint;
+        this.apiKey = opts.apiKey;
+        this.intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS;
+        this.mongooseInstance = opts.mongooseInstance;
+    }
+    start() {
+        void this.tick(); // report the current shape immediately, don't wait a full interval for the first report
+        this.timer = setInterval(() => void this.tick(), this.intervalMs);
+        if (this.timer.unref)
+            this.timer.unref();
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    // Exposed for tests and for an explicit "report now" call after a
+    // dynamic model registration; start()/the timer call this on their own.
+    async tick() {
+        let discovered;
+        try {
+            discovered = (0, mongoose_js_1.discoverMongooseSchema)(this.mongooseInstance);
+        }
+        catch {
+            return; // never let introspection failure break the host app
+        }
+        if (discovered.models.length === 0 && discovered.edges.length === 0)
+            return;
+        const json = JSON.stringify(discovered);
+        if (json === this.lastSentJSON)
+            return; // schema shape unchanged since last report
+        try {
+            const res = await (0, httpFetch_js_1.httpFetch)(this.endpoint, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'X-Reprova-Key': this.apiKey },
+                body: JSON.stringify({ models: discovered.models, edges: discovered.edges }),
+            });
+            if (res.ok) {
+                this.lastSentJSON = json;
+            }
+            else {
+                this.warnOnce(`reprova: mongo schema report returned ${res.status}`);
+            }
+        }
+        catch (err) {
+            this.warnOnce(`reprova: mongo schema report error: ${err.message}`);
+        }
+    }
+    warnOnce(msg) {
+        const now = Date.now();
+        if (now - this.lastWarnAt > WARN_INTERVAL_MS) {
+            this.lastWarnAt = now;
+            console.warn(msg);
+        }
+    }
+}
+exports.MongoSchemaReporter = MongoSchemaReporter;