@bluecopa/core 0.1.96 → 0.1.97

package/dist/api/reconV2/createReconV2.d.ts

@@ -17,6 +17,8 @@ export interface CreateReconV2Request {
     rightDataset?: ReconV2DatasetRef;
     /** Optional initial workflow config (leftDef, rightDef, matchGroups, sources, ...) */
     config?: Partial<ReconV2Workflow>;
+    /** Optional custom fields — spread into the workflow's customFields */
+    customFields?: Record<string, any>;
 }
 /**
  * Creates a recon v2 (SMART_RECONCILIATION) workflow along with its backing
@@ -29,7 +31,8 @@ export interface CreateReconV2Request {
  * @param params.leftDataset - Optional: Left dataset { id, name, dateColumn? }
  * @param params.rightDataset - Optional: Right dataset { id, name, dateColumn? }
  * @param params.config - Optional: Initial workflow config to merge in
+ * @param params.customFields - Optional: custom fields spread into the workflow's customFields
  * @returns Promise<ReconV2Workflow> The created workflow
  * @throws Error if the request fails
  */
-export declare function createReconV2({ name, type, leftDataset, rightDataset, config, }: CreateReconV2Request): Promise<ReconV2Workflow>;
+export declare function createReconV2({ name, type, leftDataset, rightDataset, config, customFields, }: CreateReconV2Request): Promise<ReconV2Workflow>;

package/dist/api/reconV2/getReconV2Templates.d.ts

@@ -0,0 +1,9 @@
+import { ReconV2TemplateCatalog } from '../../../../models/src/lib/types/reconV2TemplateTypes';
+/**
+ * Fetches the predefined recon v2 domain/exception templates used while
+ * configuring a workflow. The response is deserialised through the shared
+ * parser so callers always receive the typed catalog (keyed by domainId).
+ * @returns Promise<ReconV2TemplateCatalog> The template catalog
+ * @throws Error if the request fails
+ */
+export declare function getReconV2Templates(): Promise<ReconV2TemplateCatalog>;

package/dist/api/reconV2/getReconV2Workflow.d.ts

@@ -0,0 +1,14 @@
+import { ReconV2Workflow } from './createReconV2';
+export interface GetReconV2WorkflowRequest {
+    /** Workflow id (or its backing workbook id — the BFF resolves both) */
+    id: string;
+}
+/**
+ * Gets the detail/config of a single recon v2 workflow by id.
+ * Accepts a workflow id or its backing workbook id (resolved server-side).
+ * @param params - The request parameters
+ * @param params.id - Required: the workflow (or workbook) id
+ * @returns Promise<ReconV2Workflow> The workflow
+ * @throws Error if the request fails
+ */
+export declare function getReconV2Workflow({ id, }: GetReconV2WorkflowRequest): Promise<ReconV2Workflow>;

package/dist/api/reconV2/index.d.ts

@@ -3,6 +3,7 @@ export * from './updateReconV2';
 export * from './deleteReconV2';
 export * from './runReconV2';
 export * from './getAllReconV2Workflows';
+export * from './getReconV2Workflow';
 export * from './getReconV2Runs';
 export * from './getReconV2RunResult';
 export * from './getReconV2SmartResult';
@@ -10,3 +11,4 @@ export * from './profileReconV2';
 export * from './cleanReconV2';
 export * from './getReconV2Diff';
 export * from './getReconV2Explanation';
+export * from './getReconV2Templates';

package/dist/api/reconV2/updateReconV2.d.ts

@@ -6,6 +6,8 @@ export interface UpdateReconV2Request {
     leftDataset?: ReconV2DatasetRef;
     /** Optional: rewire the secondary (right) sheet to this dataset */
     rightDataset?: ReconV2DatasetRef;
+    /** Optional custom fields — merged (spread) into the workflow's customFields */
+    customFields?: Record<string, any>;
 }
 /**
  * Updates (saves) a recon v2 workflow config.
@@ -20,7 +22,8 @@ export interface UpdateReconV2Request {
  * @param params.reconWorkflow - Required: The workflow object with id
  * @param params.leftDataset - Optional: Left dataset { id, name, dateColumn? }
  * @param params.rightDataset - Optional: Right dataset { id, name, dateColumn? }
+ * @param params.customFields - Optional: custom fields merged into the workflow's customFields
  * @returns Promise<ReconV2Workflow> The updated workflow
  * @throws Error if the request fails
  */
-export declare function updateReconV2({ reconWorkflow, leftDataset, rightDataset, }: UpdateReconV2Request): Promise<ReconV2Workflow>;
+export declare function updateReconV2({ reconWorkflow, leftDataset, rightDataset, customFields, }: UpdateReconV2Request): Promise<ReconV2Workflow>;

package/dist/index.d.ts

@@ -14,7 +14,10 @@ export type { ReconV2Workflow, ReconV2DatasetRef, CreateReconV2Request, } from '
 export type { UpdateReconV2Request } from './api/reconV2/updateReconV2';
 export type { DeleteReconV2Request, DeleteReconV2Response, } from './api/reconV2/deleteReconV2';
 export type { ReconV2MatchConfig, RunReconV2Request, RunReconV2Response, } from './api/reconV2/runReconV2';
+export type { GetReconV2WorkflowRequest } from './api/reconV2/getReconV2Workflow';
 export type { GetReconV2RunsRequest, ReconV2Run, } from './api/reconV2/getReconV2Runs';
+export type { ReconV2TemplateCatalog, ReconV2DomainTemplate, ReconV2TemplateDomain, ReconV2TemplateItem, ReconV2TemplateTypeMapping, ReconV2TemplateFlags, ReconV2TemplateActionOverride, ReconV2SignalRule, ReconV2SignalRuleType, ReconV2TemplateOperator, ReconV2TemplateExceptionType, ReconV2TemplateMappingMode, } from '../../models/src/lib/types/reconV2TemplateTypes';
+export { parseReconV2Templates } from '../../models/src/lib/common/reconV2TemplateParser';
 export type { GetReconV2RunResultRequest, ReconV2RunResult, } from './api/reconV2/getReconV2RunResult';
 export type { GetReconV2SmartResultRequest, ReconV2SmartResult, } from './api/reconV2/getReconV2SmartResult';
 export type { ReconV2ProfileRequest, ReconV2ProfileResult, } from './api/reconV2/profileReconV2';

package/dist/index.es.js

@@ -11351,7 +11351,8 @@ async function createReconV2({
   type,
   leftDataset,
   rightDataset,
-  config
+  config,
+  customFields
 }) {
   try {
     if (!name) {
@@ -11362,7 +11363,8 @@ async function createReconV2({
       type,
       leftDataset,
       rightDataset,
-      config
+      config,
+      customFields
     });
     if (!response.data) {
       throw { message: "Failed to create recon v2 workflow", status: 500 };
@@ -11377,7 +11379,8 @@ async function createReconV2({
 async function updateReconV2({
   reconWorkflow,
   leftDataset,
-  rightDataset
+  rightDataset,
+  customFields
 }) {
   try {
     if (!reconWorkflow?.id) {
@@ -11386,7 +11389,8 @@ async function updateReconV2({
     const response = await apiClient.put("/recon-v2/update", {
       reconWorkflow,
       leftDataset,
-      rightDataset
+      rightDataset,
+      customFields
     });
     if (!response.data) {
       throw { message: "Failed to update recon v2 workflow", status: 500 };
@@ -11459,6 +11463,27 @@ async function getAllReconV2Workflows() {
     throw { message, status };
   }
 }
+async function getReconV2Workflow({
+  id
+}) {
+  try {
+    const trimmedId = id?.trim();
+    if (!trimmedId) {
+      throw { message: "Workflow id is required", status: 400 };
+    }
+    const response = await apiClient.get(
+      `/recon-v2/get/${encodeURIComponent(trimmedId)}`
+    );
+    if (!response.data) {
+      throw { message: "Failed to fetch recon v2 workflow", status: 500 };
+    }
+    return response.data;
+  } catch (error) {
+    const message = error.response?.data?.message || error.message || "An unexpected error occurred while fetching recon v2 workflow";
+    const status = error.response?.status || 500;
+    throw { message, status };
+  }
+}
 async function getReconV2Runs({
   workflowId
 }) {
@@ -11663,6 +11688,94 @@ async function getReconV2Explanation({
     throw { message, status };
   }
 }
+const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const asString = (v, fallback = "") => typeof v === "string" ? v : fallback;
+const asBool = (v, fallback = false) => typeof v === "boolean" ? v : fallback;
+const asStringOrNull = (v) => typeof v === "string" ? v : null;
+function parseSignalRule(raw) {
+  if (!isObject(raw)) return null;
+  const value = typeof raw.value === "string" || typeof raw.value === "number" ? raw.value : null;
+  return {
+    ruleType: asString(raw.ruleType),
+    col: asStringOrNull(raw.col),
+    operator: asStringOrNull(raw.operator),
+    value,
+    isNot: asBool(raw.isNot),
+    isCaseSensitive: asBool(raw.isCaseSensitive, true),
+    rules: Array.isArray(raw.rules) ? raw.rules.map(parseSignalRule).filter((r) => r !== null) : null,
+    ignoreIfColNotExists: asBool(raw.ignoreIfColNotExists)
+  };
+}
+function parseFlags(raw) {
+  if (!isObject(raw)) return null;
+  const flags = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (typeof v === "boolean") flags[k] = v;
+  }
+  return flags;
+}
+function parseTypeMapping(raw) {
+  if (!isObject(raw)) return null;
+  return {
+    exceptionType: asString(raw.exceptionType),
+    agingGate: asStringOrNull(raw.agingGate),
+    flags: parseFlags(raw.flags)
+  };
+}
+function parseItem(raw) {
+  if (!isObject(raw)) return null;
+  return {
+    name: asString(raw.name),
+    description: asString(raw.description),
+    typeMappings: Array.isArray(raw.typeMappings) ? raw.typeMappings.map(parseTypeMapping).filter((m) => m !== null) : [],
+    mappingMode: asString(raw.mappingMode, "single"),
+    signals: parseSignalRule(raw.signals),
+    actionOverride: isObject(raw.actionOverride) ? raw.actionOverride : null,
+    agingNote: asStringOrNull(raw.agingNote)
+  };
+}
+function parseDomain(raw) {
+  if (!isObject(raw)) return null;
+  return {
+    domainId: asString(raw.domainId),
+    domainName: asString(raw.domainName),
+    leftLabel: asString(raw.leftLabel),
+    rightLabel: asString(raw.rightLabel),
+    items: Array.isArray(raw.items) ? raw.items.map(parseItem).filter((i) => i !== null) : []
+  };
+}
+function parseDomainTemplate(raw) {
+  if (!isObject(raw)) return null;
+  const domain = parseDomain(raw.domain);
+  if (!domain) return null;
+  return {
+    domain,
+    signalColumns: isObject(raw.signalColumns) ? raw.signalColumns : null,
+    thresholds: isObject(raw.thresholds) ? raw.thresholds : null
+  };
+}
+function parseReconV2Templates(raw) {
+  if (!isObject(raw)) return {};
+  const catalog = {};
+  for (const [domainId, entry] of Object.entries(raw)) {
+    const parsed = parseDomainTemplate(entry);
+    if (parsed) catalog[domainId] = parsed;
+  }
+  return catalog;
+}
+async function getReconV2Templates() {
+  try {
+    const response = await apiClient.get("/recon-v2/templates");
+    if (!response.data) {
+      throw { message: "Failed to fetch recon v2 templates", status: 500 };
+    }
+    return parseReconV2Templates(response.data);
+  } catch (error) {
+    const message = error.response?.data?.message || error.message || "An unexpected error occurred while fetching recon v2 templates";
+    const status = error.response?.status || 500;
+    throw { message, status };
+  }
+}
 const index$c = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   createReconV2,
@@ -11675,6 +11788,8 @@ const index$c = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   getReconV2RunResult,
   getReconV2Runs,
   getReconV2SmartResult,
+  getReconV2Templates,
+  getReconV2Workflow,
   runReconV2,
   startReconV2Clean,
   startReconV2Profile,
@@ -15119,6 +15234,7 @@ export {
   copaInputTableDb,
   setConfig as copaSetConfig,
   bluecopaTailwindConfig as copaTailwindConfig,
-  index$l as copaUtils
+  index$l as copaUtils,
+  parseReconV2Templates
 };
 //# sourceMappingURL=index.es.js.map