@routier/core 0.4.0 → 0.6.0

package/dist/plugins/TelemetryDbPlugin.d.ts

@@ -0,0 +1,43 @@
+import { BulkPersistResult } from "../collections";
+import { PluginEventCallbackPartialResult, PluginEventCallbackResult } from "../results";
+import { ITranslatedValue } from "./translators";
+import { DbPluginBulkPersistEvent, DbPluginEvent, DbPluginQueryEvent, IDbPlugin } from "./types";
+/**
+ * Measures every operation an inner plugin performs and hands one event per call to a sink.
+ *
+ * ```ts
+ * const store = new MyStore(new TelemetryDbPlugin(new SomeDbPlugin(...)));
+ * ```
+ */
+export type TelemetryEvent = {
+    operation: "query" | "bulkPersist" | "destroy";
+    /** `id` of the plugin event that produced this measurement. */
+    eventId: string;
+    /** The class/component that triggered the operation (`event.source`). */
+    source: string;
+    /** Collection names involved, from `event.schemas`. */
+    schemas: string[];
+    durationMs: number;
+    ok: "success" | "partial" | "error";
+    /** Present when ok is "error" or "partial". */
+    error?: unknown;
+};
+export type TelemetrySink = (e: TelemetryEvent) => void;
+export type TelemetryDbPluginOptions = {
+    /** Where events go. Default: `loggerSink()`. */
+    onEvent?: TelemetrySink;
+};
+/** Default sink: writes through the levelled logger, so ROUTIER_LOG_LEVEL governs it. */
+export declare const loggerSink: () => TelemetrySink;
+/** Pushes every event into `into`. For tests and custom buffering. */
+export declare const collectingSink: (into: TelemetryEvent[]) => TelemetrySink;
+export declare class TelemetryDbPlugin implements IDbPlugin {
+    private readonly plugin;
+    private readonly onEvent;
+    constructor(plugin: IDbPlugin, options?: TelemetryDbPluginOptions);
+    get databaseName(): string;
+    query<TRoot extends {}, TShape extends any = TRoot>(event: DbPluginQueryEvent<TRoot, TShape>, done: PluginEventCallbackResult<ITranslatedValue<TShape>>): void;
+    bulkPersist(event: DbPluginBulkPersistEvent, done: PluginEventCallbackPartialResult<BulkPersistResult>): void;
+    destroy(event: DbPluginEvent, done: PluginEventCallbackResult<never>): void;
+    private emit;
+}

package/dist/plugins/index.cjs

@@ -3059,6 +3059,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
   DEFAULT_SEMI_JOIN_KEY_THRESHOLD: () => (/* reexport */ DEFAULT_SEMI_JOIN_KEY_THRESHOLD),
   TranslatedArrayValue: () => (/* reexport */ TranslatedArrayValue),
+  collectingSink: () => (/* reexport */ collectingSink),
   semiJoinFilter: () => (/* reexport */ semiJoinFilter),
   CacheDbPlugin: () => (/* reexport */ CacheDbPlugin),
   Query: () => (/* reexport */ Query),
@@ -3066,6 +3067,7 @@ __webpack_require__.d(__webpack_exports__, {
   executeJoin: () => (/* reexport */ executeJoin),
   formatExplanation: () => (/* reexport */ formatExplanation),
   serializePersistResult: () => (/* reexport */ serializePersistResult),
+  mappedResultColumns: () => (/* reexport */ mappedResultColumns),
   explainQuery: () => (/* reexport */ explainQuery),
   cosineDistance: () => (/* reexport */ cosineDistance),
   RetryDbPlugin: () => (/* reexport */ RetryDbPlugin),
@@ -3080,16 +3082,18 @@ __webpack_require__.d(__webpack_exports__, {
   EXECUTED_QUERIES_UNSUPPORTED: () => (/* reexport */ EXECUTED_QUERIES_UNSUPPORTED),
   joinInPlugin: () => (/* reexport */ joinInPlugin),
   deserializePersistResult: () => (/* reexport */ deserializePersistResult),
+  loggerSink: () => (/* reexport */ loggerSink),
   nearestBy: () => (/* reexport */ nearestBy),
   readJoinKey: () => (/* reexport */ readJoinKey),
-  serializeBulkPersist: () => (/* reexport */ serializeBulkPersist),
   hashJoin: () => (/* reexport */ hashJoin),
   EphemeralDataPlugin: () => (/* reexport */ EphemeralDataPlugin),
   QueryOptionsCollection: () => (/* reexport */ QueryOptionsCollection/* .QueryOptionsCollection */.H),
+  serializeBulkPersist: () => (/* reexport */ serializeBulkPersist),
   toEntityShape: () => (/* reexport */ toEntityShape),
   loadJoinInnerSide: () => (/* reexport */ loadJoinInnerSide),
   DataTranslator: () => (/* reexport */ DataTranslator),
   withExecutedQueries: () => (/* reexport */ withExecutedQueries),
+  TelemetryDbPlugin: () => (/* reexport */ TelemetryDbPlugin),
   createRequestHandler: () => (/* reexport */ createRequestHandler),
   SqlTranslator: () => (/* reexport */ SqlTranslator),
   QueryOrdering: () => (/* reexport */ types_QueryOrdering),
@@ -3099,6 +3103,18 @@ __webpack_require__.d(__webpack_exports__, {
   deserializeQueryOptions: () => (/* reexport */ deserializeQueryOptions)
 });
 
+;// CONCATENATED MODULE: ./src/plugins/resultShape.ts
+/**
+ * The columns a `map` projection selects.
+ *
+ * Named by `sourceName`, which is what the statement actually emits; the rename to
+ * `destinationName` happens in the translator, after the rows come back. A field with no
+ * `property` is an expression.
+ */ const mappedResultColumns = (fields)=>fields.map((field)=>({
+            name: field.sourceName,
+            property: field.property ?? null
+        }));
+
 ;// CONCATENATED MODULE: ./src/plugins/translators/TranslatedArrayValue.ts
 class TranslatedArrayValue {
     value;
@@ -6080,6 +6096,69 @@ class RetryDbPlugin {
     }
 }
 
+;// CONCATENATED MODULE: ./src/plugins/TelemetryDbPlugin.ts
+
+/** Default sink: writes through the levelled logger, so ROUTIER_LOG_LEVEL governs it. */ const loggerSink = ()=>(e)=>{
+        const line = `[routier] ${e.operation} ${e.schemas.join(",")} ${e.durationMs.toFixed(1)}ms`;
+        if (e.ok === "error") {
+            logger/* .logger.error */.vF.error(line, e.error);
+            return;
+        }
+        logger/* .logger.info */.vF.info(line);
+    };
+/** Pushes every event into `into`. For tests and custom buffering. */ const collectingSink = (into)=>(e)=>{
+        into.push(e);
+    };
+class TelemetryDbPlugin {
+    plugin;
+    onEvent;
+    constructor(plugin, options = {}){
+        this.plugin = plugin;
+        this.onEvent = options.onEvent ?? loggerSink();
+    }
+    get databaseName() {
+        return this.plugin.databaseName;
+    }
+    query(event, done) {
+        const start = performance.now();
+        this.plugin.query(event, (result)=>{
+            this.emit("query", event, result, start);
+            done(result);
+        });
+    }
+    bulkPersist(event, done) {
+        const start = performance.now();
+        this.plugin.bulkPersist(event, (result)=>{
+            this.emit("bulkPersist", event, result, start);
+            done(result);
+        });
+    }
+    destroy(event, done) {
+        const start = performance.now();
+        this.plugin.destroy(event, (result)=>{
+            this.emit("destroy", event, result, start);
+            done(result);
+        });
+    }
+    emit(operation, event, result, start) {
+        try {
+            this.onEvent({
+                operation,
+                eventId: event.id,
+                source: event.source,
+                schemas: [
+                    ...event.schemas.values()
+                ].map((s)=>s.collectionName),
+                durationMs: performance.now() - start,
+                ok: result.ok,
+                error: result.ok === "success" ? undefined : result.error
+            });
+        } catch  {
+        // A broken sink must never fail the data operation.
+        }
+    }
+}
+
 ;// CONCATENATED MODULE: ./src/plugins/CacheDbPlugin.ts
 
 /**
@@ -6543,6 +6622,8 @@ const DEFAULT_MAX_BATCH_SIZE = 100;
 
 
 
+
+
 })();
 
 module.exports = __webpack_exports__;