@memberjunction/record-set-processor-base 5.43.0 → 5.44.0

package/dist/index.d.ts

@@ -6,4 +6,5 @@
 export * from './types.js';
 export * from './interfaces.js';
 export * from './sources/index.js';
+export * from './registry.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -6,6 +6,7 @@
 export * from './types.js';
 export * from './interfaces.js';
 export * from './sources/index.js';
+export * from './registry.js';
 // The RecordProcess.RunNow Remote Operation base + RecordProcessScopeOverride/RecordProcessRunNowInput/Output
 // are now CodeGen-emitted into @memberjunction/core-entities (generated/remote_operations.ts) from the
 // MJ: Remote Operations metadata row.

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,8GAA8G;AAC9G,uGAAuG;AACvG,sCAAsC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,8GAA8G;AAC9G,uGAAuG;AACvG,sCAAsC"}

package/dist/registry.d.ts

@@ -0,0 +1,94 @@
+/**
+ * @fileoverview The **processor registry** — the open seam that lets external packages teach the
+ * Record Set Processing substrate about new work types WITHOUT the base package depending on them.
+ *
+ * The engine's `RecordProcessExecutor.buildProcessor()` handles the built-in work types
+ * (`FieldRules` / `Action` / `Agent` / `Infer`) directly, then consults this registry for any work
+ * type its switch doesn't recognize before failing. A consumer package (e.g. Predictive Studio's
+ * `'ML Model'` scoring) registers a factory keyed by its work-type string; the factory closes over
+ * whatever injected dependencies that consumer needs (sidecars, loaders, etc.) and constructs its
+ * `IRecordProcessor` from the per-run build context.
+ *
+ * @module @memberjunction/record-set-processor-base
+ */
+import { BaseSingleton } from '@memberjunction/global';
+import { IRecordProcessor } from './interfaces.js';
+/**
+ * The per-run context handed to a registered factory. Carries the resolved Record Process fields the
+ * factory needs to build its processor, plus the dry-run flag, WITHOUT coupling the base package to
+ * the `MJRecordProcessEntity` type (the base package depends only on `@memberjunction/core` +
+ * `@memberjunction/global`). The engine populates this from the loaded Record Process; the registered
+ * factory reads `Configuration` / `InputMapping` to build itself.
+ */
+export interface RecordProcessorBuildContext {
+    /** The work-type key being built (the registry lookup key). */
+    WorkType: string;
+    /** The Record Process's `Configuration` JSON string (work-type-specific config), if any. */
+    Configuration?: string | null;
+    /** The Record Process's `InputMapping` JSON string, if any. */
+    InputMapping?: string | null;
+    /** The Record Process's `OutputMapping` JSON string, if any (write-back targets). */
+    OutputMapping?: string | null;
+    /** The target entity id of the Record Process. */
+    EntityID?: string;
+    /** The Record Process id (lineage / diagnostics). */
+    RecordProcessID?: string;
+    /** The Record Process name (diagnostics). */
+    RecordProcessName?: string;
+    /** True when this is a dry-run (compute-only) pass — the factory should honor it when supported. */
+    DryRun?: boolean;
+    /**
+     * The loaded Record Process record itself, as an opaque object. The engine passes the real
+     * `MJRecordProcessEntity`; a factory that needs fields beyond those projected above can read them
+     * off this with its own typing. Typed as `unknown` so the base package stays free of
+     * `@memberjunction/core-entities`.
+     */
+    RecordProcess?: unknown;
+}
+/**
+ * Factory that builds an {@link IRecordProcessor} for a registered work type. Returning `null` (or
+ * `undefined`) signals "not applicable" so the executor can continue (defensive — normally a factory
+ * registered for a work type always builds for it). The factory may throw to surface a configuration
+ * error (e.g. a missing required id), exactly as the built-in work types do.
+ */
+export type RecordProcessorFactory = (context: RecordProcessorBuildContext) => IRecordProcessor | null | undefined;
+/**
+ * Process-wide registry of work-type → processor factory, used by the engine's `buildProcessor()` to
+ * resolve work types beyond its built-ins. A {@link BaseSingleton} so there is exactly one instance
+ * across the process even when a bundler duplicates the module (per CLAUDE.md rule 7).
+ *
+ * Work-type keys are matched case-insensitively (trimmed), so a consumer can register `'ML Model'`
+ * and the executor resolves it whether the Record Process row stores `'ML Model'` or `'ml model'`.
+ */
+export declare class RecordProcessorRegistry extends BaseSingleton<RecordProcessorRegistry> {
+    /** work-type (normalized) → factory. */
+    private readonly factories;
+    /** @internal — use {@link RecordProcessorRegistry.Instance}. */
+    protected constructor();
+    /** The single process-wide registry instance. */
+    static get Instance(): RecordProcessorRegistry;
+    /** Normalize a work-type key for case/whitespace-insensitive matching. */
+    private normalize;
+    /**
+     * Register a factory for a work-type key. A later registration for the same key overrides the
+     * earlier one (last-wins), which lets a consumer replace a default.
+     *
+     * @param workType the work-type string (e.g. `'ML Model'`), matched case-insensitively
+     * @param factory builds the processor for that work type from the per-run context
+     */
+    Register(workType: string, factory: RecordProcessorFactory): void;
+    /** Whether a factory is registered for the given work type (case-insensitive). */
+    Has(workType: string | null | undefined): boolean;
+    /**
+     * Resolve and invoke the factory for a work type, returning the built processor or `null` when no
+     * factory is registered (or the factory itself declined by returning null/undefined).
+     *
+     * @param context the per-run build context (work type + Record Process fields)
+     */
+    Resolve(context: RecordProcessorBuildContext): IRecordProcessor | null;
+    /** The set of registered work-type keys (normalized). Primarily for diagnostics/tests. */
+    get RegisteredWorkTypes(): string[];
+    /** Remove a registration (case-insensitive). Returns whether one was present. Primarily for tests. */
+    Unregister(workType: string): boolean;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEhD;;;;;;GAMG;AACH,MAAM,WAAW,2BAA2B;IACxC,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,CAAC;IACjB,4FAA4F;IAC5F,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,+DAA+D;IAC/D,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,qFAAqF;IACrF,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,kDAAkD;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qDAAqD;IACrD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,6CAA6C;IAC7C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,oGAAoG;IACpG,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,EAAE,2BAA2B,KAAK,gBAAgB,GAAG,IAAI,GAAG,SAAS,CAAC;AAEnH;;;;;;;GAOG;AACH,qBAAa,uBAAwB,SAAQ,aAAa,CAAC,uBAAuB,CAAC;IAC/E,wCAAwC;IACxC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6C;IAEvE,gEAAgE;IAChE,SAAS;IAIT,iDAAiD;IACjD,WAAkB,QAAQ,IAAI,uBAAuB,CAEpD;IAED,0EAA0E;IAC1E,OAAO,CAAC,SAAS;IAIjB;;;;;;OAMG;IACI,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB,GAAG,IAAI;IAOxE,kFAAkF;IAC3E,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO;IAIxD;;;;;OAKG;IACI,OAAO,CAAC,OAAO,EAAE,2BAA2B,GAAG,gBAAgB,GAAG,IAAI;IAQ7E,0FAA0F;IAC1F,IAAW,mBAAmB,IAAI,MAAM,EAAE,CAEzC;IAED,sGAAsG;IAC/F,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;CAG/C"}

package/dist/registry.js

@@ -0,0 +1,77 @@
+/**
+ * @fileoverview The **processor registry** — the open seam that lets external packages teach the
+ * Record Set Processing substrate about new work types WITHOUT the base package depending on them.
+ *
+ * The engine's `RecordProcessExecutor.buildProcessor()` handles the built-in work types
+ * (`FieldRules` / `Action` / `Agent` / `Infer`) directly, then consults this registry for any work
+ * type its switch doesn't recognize before failing. A consumer package (e.g. Predictive Studio's
+ * `'ML Model'` scoring) registers a factory keyed by its work-type string; the factory closes over
+ * whatever injected dependencies that consumer needs (sidecars, loaders, etc.) and constructs its
+ * `IRecordProcessor` from the per-run build context.
+ *
+ * @module @memberjunction/record-set-processor-base
+ */
+import { BaseSingleton } from '@memberjunction/global';
+/**
+ * Process-wide registry of work-type → processor factory, used by the engine's `buildProcessor()` to
+ * resolve work types beyond its built-ins. A {@link BaseSingleton} so there is exactly one instance
+ * across the process even when a bundler duplicates the module (per CLAUDE.md rule 7).
+ *
+ * Work-type keys are matched case-insensitively (trimmed), so a consumer can register `'ML Model'`
+ * and the executor resolves it whether the Record Process row stores `'ML Model'` or `'ml model'`.
+ */
+export class RecordProcessorRegistry extends BaseSingleton {
+    /** @internal — use {@link RecordProcessorRegistry.Instance}. */
+    constructor() {
+        super();
+        /** work-type (normalized) → factory. */
+        this.factories = new Map();
+    }
+    /** The single process-wide registry instance. */
+    static get Instance() {
+        return super.getInstance();
+    }
+    /** Normalize a work-type key for case/whitespace-insensitive matching. */
+    normalize(workType) {
+        return workType.trim().toLowerCase();
+    }
+    /**
+     * Register a factory for a work-type key. A later registration for the same key overrides the
+     * earlier one (last-wins), which lets a consumer replace a default.
+     *
+     * @param workType the work-type string (e.g. `'ML Model'`), matched case-insensitively
+     * @param factory builds the processor for that work type from the per-run context
+     */
+    Register(workType, factory) {
+        if (!workType || !workType.trim()) {
+            throw new Error('RecordProcessorRegistry.Register: workType must be a non-empty string');
+        }
+        this.factories.set(this.normalize(workType), factory);
+    }
+    /** Whether a factory is registered for the given work type (case-insensitive). */
+    Has(workType) {
+        return workType != null && this.factories.has(this.normalize(workType));
+    }
+    /**
+     * Resolve and invoke the factory for a work type, returning the built processor or `null` when no
+     * factory is registered (or the factory itself declined by returning null/undefined).
+     *
+     * @param context the per-run build context (work type + Record Process fields)
+     */
+    Resolve(context) {
+        const factory = context.WorkType != null ? this.factories.get(this.normalize(context.WorkType)) : undefined;
+        if (!factory) {
+            return null;
+        }
+        return factory(context) ?? null;
+    }
+    /** The set of registered work-type keys (normalized). Primarily for diagnostics/tests. */
+    get RegisteredWorkTypes() {
+        return Array.from(this.factories.keys());
+    }
+    /** Remove a registration (case-insensitive). Returns whether one was present. Primarily for tests. */
+    Unregister(workType) {
+        return this.factories.delete(this.normalize(workType));
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AA4CvD;;;;;;;GAOG;AACH,MAAM,OAAO,uBAAwB,SAAQ,aAAsC;IAI/E,gEAAgE;IAChE;QACI,KAAK,EAAE,CAAC;QALZ,wCAAwC;QACvB,cAAS,GAAG,IAAI,GAAG,EAAkC,CAAC;IAKvE,CAAC;IAED,iDAAiD;IAC1C,MAAM,KAAK,QAAQ;QACtB,OAAO,KAAK,CAAC,WAAW,EAA2B,CAAC;IACxD,CAAC;IAED,0EAA0E;IAClE,SAAS,CAAC,QAAgB;QAC9B,OAAO,QAAQ,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACzC,CAAC;IAED;;;;;;OAMG;IACI,QAAQ,CAAC,QAAgB,EAAE,OAA+B;QAC7D,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC;YAChC,MAAM,IAAI,KAAK,CAAC,uEAAuE,CAAC,CAAC;QAC7F,CAAC;QACD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAC;IAC1D,CAAC;IAED,kFAAkF;IAC3E,GAAG,CAAC,QAAmC;QAC1C,OAAO,QAAQ,IAAI,IAAI,IAAI,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC5E,CAAC;IAED;;;;;OAKG;IACI,OAAO,CAAC,OAAoC;QAC/C,MAAM,OAAO,GAAG,OAAO,CAAC,QAAQ,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC5G,IAAI,CAAC,OAAO,EAAE,CAAC;YACX,OAAO,IAAI,CAAC;QAChB,CAAC;QACD,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;IACpC,CAAC;IAED,0FAA0F;IAC1F,IAAW,mBAAmB;QAC1B,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC;IAC7C,CAAC;IAED,sGAAsG;IAC/F,UAAU,CAAC,QAAgB;QAC9B,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC3D,CAAC;CACJ"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@memberjunction/record-set-processor-base",
   "type": "module",
-  "version": "5.43.0",
+  "version": "5.44.0",
   "description": "MemberJunction: Record Set Processor Base - interfaces, types, and source adapters for batched, resumable record-set processing. Client-safe.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,8 +17,8 @@
   "author": "MemberJunction.com",
   "license": "ISC",
   "dependencies": {
-    "@memberjunction/core": "5.43.0",
-    "@memberjunction/global": "5.43.0"
+    "@memberjunction/core": "5.44.0",
+    "@memberjunction/global": "5.44.0"
   },
   "devDependencies": {
     "@types/node": "24.10.11",