@workbench-kit/field-remap 0.0.1-prototype.0 → 0.0.2-prototype.0.2.10

package/src/domain/ingest/sourceFieldsFromPlainObject.ts

@@ -1,103 +1,103 @@
-import { isPlainObject } from '../mapping/pathUtils.js';
-import type { FieldDataType, SourceField } from '../types.js';
-
-export interface SourceFieldsFromPlainObjectOptions {
-  /** Prefix for generated field ids (default `src`). */
-  readonly idPrefix?: string;
-  /** Max nesting depth for object children (default 4). */
-  readonly maxDepth?: number;
-}
-
-function inferDataType(value: unknown): FieldDataType {
-  if (value === null || value === undefined) {
-    return 'unknown';
-  }
-  if (typeof value === 'string') {
-    return 'string';
-  }
-  if (typeof value === 'number' && Number.isFinite(value)) {
-    return 'number';
-  }
-  if (typeof value === 'boolean') {
-    return 'boolean';
-  }
-  if (value instanceof Date && !Number.isNaN(value.getTime())) {
-    return 'datetime';
-  }
-  if (Array.isArray(value)) {
-    return 'array';
-  }
-  if (isPlainObject(value)) {
-    return 'object';
-  }
-  return 'unknown';
-}
-
-function fieldFromEntry(
-  key: string,
-  value: unknown,
-  path: string,
-  idPrefix: string,
-  depth: number,
-  maxDepth: number,
-): SourceField {
-  const id = path ? `${idPrefix}.${path}` : `${idPrefix}.${key}`;
-  const dataType = inferDataType(value);
-  const base: SourceField = {
-    id,
-    label: key,
-    path,
-    dataType,
-    sampleValue: value,
-  };
-
-  if (depth >= maxDepth) {
-    return base;
-  }
-
-  if (isPlainObject(value)) {
-    const children = Object.entries(value).map(([childKey, childValue]) =>
-      fieldFromEntry(
-        childKey,
-        childValue,
-        path ? `${path}.${childKey}` : childKey,
-        idPrefix,
-        depth + 1,
-        maxDepth,
-      ),
-    );
-    return children.length > 0 ? { ...base, children } : base;
-  }
-
-  if (Array.isArray(value) && value.length > 0 && isPlainObject(value[0])) {
-    const sampleItem = value[0] as Record<string, unknown>;
-    const children = Object.entries(sampleItem).map(([childKey, childValue]) =>
-      fieldFromEntry(childKey, childValue, childKey, `${id}.item`, depth + 1, maxDepth),
-    );
-    return children.length > 0 ? { ...base, children } : base;
-  }
-
-  return base;
-}
-
-/**
- * Infer a shallow/nested `SourceField` tree from a plain sample object.
- * Useful for demos and hosts that have a sample payload but no formal schema.
- *
- * - Top-level keys become root fields.
- * - Nested plain objects become `children` (up to `maxDepth`).
- * - Arrays of objects expose item-key children for projection pickers.
- */
-export function sourceFieldsFromPlainObject(
-  sample: unknown,
-  options: SourceFieldsFromPlainObjectOptions = {},
-): SourceField[] {
-  if (!isPlainObject(sample)) {
-    return [];
-  }
-  const idPrefix = options.idPrefix?.trim() || 'src';
-  const maxDepth = Math.max(0, options.maxDepth ?? 4);
-  return Object.entries(sample).map(([key, value]) =>
-    fieldFromEntry(key, value, key, idPrefix, 0, maxDepth),
-  );
-}
+import { isPlainObject } from '../mapping/pathUtils.js';
+import type { FieldDataType, SourceField } from '../types.js';
+
+export interface SourceFieldsFromPlainObjectOptions {
+  /** Prefix for generated field ids (default `src`). */
+  readonly idPrefix?: string;
+  /** Max nesting depth for object children (default 4). */
+  readonly maxDepth?: number;
+}
+
+function inferDataType(value: unknown): FieldDataType {
+  if (value === null || value === undefined) {
+    return 'unknown';
+  }
+  if (typeof value === 'string') {
+    return 'string';
+  }
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return 'number';
+  }
+  if (typeof value === 'boolean') {
+    return 'boolean';
+  }
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return 'datetime';
+  }
+  if (Array.isArray(value)) {
+    return 'array';
+  }
+  if (isPlainObject(value)) {
+    return 'object';
+  }
+  return 'unknown';
+}
+
+function fieldFromEntry(
+  key: string,
+  value: unknown,
+  path: string,
+  idPrefix: string,
+  depth: number,
+  maxDepth: number,
+): SourceField {
+  const id = path ? `${idPrefix}.${path}` : `${idPrefix}.${key}`;
+  const dataType = inferDataType(value);
+  const base: SourceField = {
+    id,
+    label: key,
+    path,
+    dataType,
+    sampleValue: value,
+  };
+
+  if (depth >= maxDepth) {
+    return base;
+  }
+
+  if (isPlainObject(value)) {
+    const children = Object.entries(value).map(([childKey, childValue]) =>
+      fieldFromEntry(
+        childKey,
+        childValue,
+        path ? `${path}.${childKey}` : childKey,
+        idPrefix,
+        depth + 1,
+        maxDepth,
+      ),
+    );
+    return children.length > 0 ? { ...base, children } : base;
+  }
+
+  if (Array.isArray(value) && value.length > 0 && isPlainObject(value[0])) {
+    const sampleItem = value[0] as Record<string, unknown>;
+    const children = Object.entries(sampleItem).map(([childKey, childValue]) =>
+      fieldFromEntry(childKey, childValue, childKey, `${id}.item`, depth + 1, maxDepth),
+    );
+    return children.length > 0 ? { ...base, children } : base;
+  }
+
+  return base;
+}
+
+/**
+ * Infer a shallow/nested `SourceField` tree from a plain sample object.
+ * Useful for demos and hosts that have a sample payload but no formal schema.
+ *
+ * - Top-level keys become root fields.
+ * - Nested plain objects become `children` (up to `maxDepth`).
+ * - Arrays of objects expose item-key children for projection pickers.
+ */
+export function sourceFieldsFromPlainObject(
+  sample: unknown,
+  options: SourceFieldsFromPlainObjectOptions = {},
+): SourceField[] {
+  if (!isPlainObject(sample)) {
+    return [];
+  }
+  const idPrefix = options.idPrefix?.trim() || 'src';
+  const maxDepth = Math.max(0, options.maxDepth ?? 4);
+  return Object.entries(sample).map(([key, value]) =>
+    fieldFromEntry(key, value, key, idPrefix, 0, maxDepth),
+  );
+}

package/src/domain/ingest/targetSlotsFromPlainObject.ts

@@ -1,41 +1,41 @@
-import { sourceFieldsFromPlainObject } from './sourceFieldsFromPlainObject.js';
-import type { SourceField, TargetSlot } from '../types.js';
-
-export interface TargetSlotsFromPlainObjectOptions {
-  /** Prefix for generated slot ids (default `tgt`). */
-  readonly idPrefix?: string;
-  /** Max nesting depth for object children (default 4). */
-  readonly maxDepth?: number;
-}
-
-function sourceFieldToTargetSlot(field: SourceField): TargetSlot {
-  const slot: TargetSlot = {
-    id: field.id,
-    label: field.label,
-    ...(field.path ? { path: field.path } : {}),
-    ...(field.dataType ? { dataType: field.dataType } : {}),
-  };
-  if (field.children && field.children.length > 0) {
-    return {
-      ...slot,
-      children: field.children.map(sourceFieldToTargetSlot),
-    };
-  }
-  return slot;
-}
-
-/**
- * Infer a nested `TargetSlot` tree from a plain sample object (or target shape).
- * Mirrors {@link sourceFieldsFromPlainObject}: same nesting / array-of-object rules,
- * keeping `path` for `convertToShape` output assembly (no `sampleValue`).
- */
-export function targetSlotsFromPlainObject(
-  sample: unknown,
-  options: TargetSlotsFromPlainObjectOptions = {},
-): TargetSlot[] {
-  const idPrefix = options.idPrefix?.trim() || 'tgt';
-  return sourceFieldsFromPlainObject(sample, {
-    idPrefix,
-    maxDepth: options.maxDepth,
-  }).map(sourceFieldToTargetSlot);
-}
+import { sourceFieldsFromPlainObject } from './sourceFieldsFromPlainObject.js';
+import type { SourceField, TargetSlot } from '../types.js';
+
+export interface TargetSlotsFromPlainObjectOptions {
+  /** Prefix for generated slot ids (default `tgt`). */
+  readonly idPrefix?: string;
+  /** Max nesting depth for object children (default 4). */
+  readonly maxDepth?: number;
+}
+
+function sourceFieldToTargetSlot(field: SourceField): TargetSlot {
+  const slot: TargetSlot = {
+    id: field.id,
+    label: field.label,
+    ...(field.path ? { path: field.path } : {}),
+    ...(field.dataType ? { dataType: field.dataType } : {}),
+  };
+  if (field.children && field.children.length > 0) {
+    return {
+      ...slot,
+      children: field.children.map(sourceFieldToTargetSlot),
+    };
+  }
+  return slot;
+}
+
+/**
+ * Infer a nested `TargetSlot` tree from a plain sample object (or target shape).
+ * Mirrors {@link sourceFieldsFromPlainObject}: same nesting / array-of-object rules,
+ * keeping `path` for `convertToShape` output assembly (no `sampleValue`).
+ */
+export function targetSlotsFromPlainObject(
+  sample: unknown,
+  options: TargetSlotsFromPlainObjectOptions = {},
+): TargetSlot[] {
+  const idPrefix = options.idPrefix?.trim() || 'tgt';
+  return sourceFieldsFromPlainObject(sample, {
+    idPrefix,
+    maxDepth: options.maxDepth,
+  }).map(sourceFieldToTargetSlot);
+}

package/src/domain/mapping/convertItemEdges.ts

@@ -1,93 +1,98 @@
-import { edgeTransformIds } from '../document/mappingEdge.js';
-import { applyTransformChain } from '../../registry/createValueTransformRegistry.js';
-import { BUILTIN_TRANSFORM_IDS } from '../../registry/builtinTransforms.js';
-import { resolveOptionSteps } from './transformOptions.js';
-import { isPlainObject, readObjectPath, writeObjectPath } from './pathUtils.js';
-import { findTargetSlot, flattenSourceFields, flattenTargetSlots } from './treeUtils.js';
-import type {
-  MappingEdge,
-  SourceField,
-  TargetSlot,
-  TransformContext,
-  ValueTransformRegistry,
-} from '../types.js';
-
-function findSourceField(fields: readonly SourceField[], fieldId: string): SourceField | undefined {
-  return flattenSourceFields(fields).find((field) => field.id === fieldId);
-}
-
-function itemRelativePath(
-  node: { readonly path?: string; readonly label: string; readonly id: string } | undefined,
-): string {
-  if (!node) {
-    return '';
-  }
-  const path = node.path?.trim();
-  if (path) {
-    return path;
-  }
-  return node.label.trim() || node.id.split('.').pop() || '';
-}
-
-/**
- * Convert each object in a source array through list-context `itemEdges`.
- * Child field paths are treated as item-relative (ingest array children).
- */
-export function convertArrayWithItemEdges(input: {
-  readonly items: unknown;
-  readonly itemEdges: readonly MappingEdge[];
-  readonly sources: readonly SourceField[];
-  readonly targets: readonly TargetSlot[];
-  readonly transforms: ValueTransformRegistry;
-  readonly context?: TransformContext;
-}): unknown[] {
-  if (!Array.isArray(input.items)) {
-    return [];
-  }
-
-  const targetLeaves = flattenTargetSlots(input.targets);
-
-  return input.items.map((rawItem) => {
-    const item = isPlainObject(rawItem) ? rawItem : {};
-    let outItem: Record<string, unknown> = {};
-
-    for (const edge of input.itemEdges) {
-      const sourceField = findSourceField(input.sources, edge.sourceFieldId);
-      const targetSlot =
-        findTargetSlot(input.targets, edge.targetSlotId) ??
-        targetLeaves.find((slot) => slot.id === edge.targetSlotId);
-      if (!sourceField || !targetSlot) {
-        continue;
-      }
-
-      const sourcePath = itemRelativePath(sourceField);
-      const sourceValue = sourcePath ? readObjectPath(item, sourcePath) : undefined;
-
-      const chain = edgeTransformIds(edge);
-      let value: unknown;
-      if (chain.length === 0) {
-        const identity = input.transforms.get(BUILTIN_TRANSFORM_IDS.identity);
-        value = identity
-          ? identity.apply(sourceValue, { ...input.context, sampleValue: sourceValue })
-          : sourceValue;
-      } else {
-        const steps = resolveOptionSteps(chain, edge.transformOptionSteps, edge.transformOptions);
-        value = applyTransformChain(
-          input.transforms,
-          chain,
-          sourceValue,
-          { ...input.context, sampleValue: sourceValue },
-          steps,
-        );
-      }
-
-      const targetPath = itemRelativePath(targetSlot);
-      if (!targetPath) {
-        continue;
-      }
-      outItem = writeObjectPath(outItem, targetPath, value);
-    }
-
-    return outItem;
-  });
-}
+import { throwIfAborted } from '../abort.js';
+import { edgeTransformIds } from '../document/mappingEdge.js';
+import { applyTransformChain } from '../../registry/createValueTransformRegistry.js';
+import { BUILTIN_TRANSFORM_IDS } from '../../registry/builtinTransforms.js';
+import { resolveOptionSteps } from './transformOptions.js';
+import { isPlainObject, readObjectPath, writeObjectPath } from './pathUtils.js';
+import { findTargetSlot, flattenSourceFields, flattenTargetSlots } from './treeUtils.js';
+import type {
+  MappingEdge,
+  SourceField,
+  TargetSlot,
+  TransformContext,
+  ValueTransformRegistry,
+} from '../types.js';
+
+function findSourceField(fields: readonly SourceField[], fieldId: string): SourceField | undefined {
+  return flattenSourceFields(fields).find((field) => field.id === fieldId);
+}
+
+function itemRelativePath(
+  node: { readonly path?: string; readonly label: string; readonly id: string } | undefined,
+): string {
+  if (!node) {
+    return '';
+  }
+  const path = node.path?.trim();
+  if (path) {
+    return path;
+  }
+  return node.label.trim() || node.id.split('.').pop() || '';
+}
+
+/**
+ * Convert each object in a source array through list-context `itemEdges`.
+ * Child field paths are treated as item-relative (ingest array children).
+ */
+export async function convertArrayWithItemEdges(input: {
+  readonly items: unknown;
+  readonly itemEdges: readonly MappingEdge[];
+  readonly sources: readonly SourceField[];
+  readonly targets: readonly TargetSlot[];
+  readonly transforms: ValueTransformRegistry;
+  readonly context?: TransformContext;
+}): Promise<unknown[]> {
+  if (!Array.isArray(input.items)) {
+    return [];
+  }
+
+  const targetLeaves = flattenTargetSlots(input.targets);
+
+  return Promise.all(
+    input.items.map(async (rawItem) => {
+      const item = isPlainObject(rawItem) ? rawItem : {};
+      let outItem: Record<string, unknown> = {};
+
+      for (const edge of input.itemEdges) {
+        throwIfAborted(input.context?.signal);
+
+        const sourceField = findSourceField(input.sources, edge.sourceFieldId);
+        const targetSlot =
+          findTargetSlot(input.targets, edge.targetSlotId) ??
+          targetLeaves.find((slot) => slot.id === edge.targetSlotId);
+        if (!sourceField || !targetSlot) {
+          continue;
+        }
+
+        const sourcePath = itemRelativePath(sourceField);
+        const sourceValue = sourcePath ? readObjectPath(item, sourcePath) : undefined;
+
+        const chain = edgeTransformIds(edge);
+        let value: unknown;
+        if (chain.length === 0) {
+          const identity = input.transforms.get(BUILTIN_TRANSFORM_IDS.identity);
+          value = identity
+            ? await identity.apply(sourceValue, { ...input.context, sampleValue: sourceValue })
+            : sourceValue;
+        } else {
+          const steps = resolveOptionSteps(chain, edge.transformOptionSteps, edge.transformOptions);
+          value = await applyTransformChain(
+            input.transforms,
+            chain,
+            sourceValue,
+            { ...input.context, sampleValue: sourceValue },
+            steps,
+          );
+        }
+
+        const targetPath = itemRelativePath(targetSlot);
+        if (!targetPath) {
+          continue;
+        }
+        outItem = writeObjectPath(outItem, targetPath, value);
+      }
+
+      return outItem;
+    }),
+  );
+}