@contractspec/example.integration-hub 2.5.0 → 2.6.1

package/dist/browser/sync/sync.presentation.js

@@ -1,301 +0,0 @@
-// src/sync/sync.enum.ts
-import { defineEnum } from "@contractspec/lib.schema";
-var SyncDirectionEnum = defineEnum("SyncDirection", [
-  "INBOUND",
-  "OUTBOUND",
-  "BIDIRECTIONAL"
-]);
-var SyncStatusEnum = defineEnum("SyncStatus", [
-  "PENDING",
-  "RUNNING",
-  "COMPLETED",
-  "FAILED",
-  "CANCELLED"
-]);
-var MappingTypeEnum = defineEnum("MappingType", [
-  "DIRECT",
-  "TRANSFORM",
-  "LOOKUP",
-  "CONSTANT",
-  "COMPUTED"
-]);
-
-// src/sync/sync.schema.ts
-import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
-var FieldMappingModel = defineSchemaModel({
-  name: "FieldMappingModel",
-  fields: {
-    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    sourceField: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    targetField: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    mappingType: { type: MappingTypeEnum, isOptional: false },
-    transformExpression: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: true
-    },
-    isRequired: { type: ScalarTypeEnum.Boolean(), isOptional: false }
-  }
-});
-var SyncConfigModel = defineSchemaModel({
-  name: "SyncConfigModel",
-  fields: {
-    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    integrationId: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false
-    },
-    connectionId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    direction: { type: SyncDirectionEnum, isOptional: false },
-    sourceObject: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    targetObject: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    scheduleEnabled: { type: ScalarTypeEnum.Boolean(), isOptional: false },
-    scheduleCron: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    isActive: { type: ScalarTypeEnum.Boolean(), isOptional: false },
-    lastSyncAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
-    fieldMappings: { type: FieldMappingModel, isArray: true, isOptional: true }
-  }
-});
-var SyncRunModel = defineSchemaModel({
-  name: "SyncRunModel",
-  fields: {
-    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    syncConfigId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    status: { type: SyncStatusEnum, isOptional: false },
-    direction: { type: SyncDirectionEnum, isOptional: false },
-    trigger: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    recordsProcessed: {
-      type: ScalarTypeEnum.Int_unsecure(),
-      isOptional: false
-    },
-    recordsCreated: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    recordsUpdated: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    recordsFailed: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    errorMessage: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    startedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
-    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
-    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
-  }
-});
-var CreateSyncConfigInputModel = defineSchemaModel({
-  name: "CreateSyncConfigInput",
-  fields: {
-    integrationId: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false
-    },
-    connectionId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
-    direction: { type: SyncDirectionEnum, isOptional: false },
-    sourceObject: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
-    targetObject: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
-    scheduleEnabled: { type: ScalarTypeEnum.Boolean(), isOptional: true },
-    scheduleCron: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
-  }
-});
-var AddFieldMappingInputModel = defineSchemaModel({
-  name: "AddFieldMappingInput",
-  fields: {
-    syncConfigId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    sourceField: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
-    targetField: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
-    mappingType: { type: MappingTypeEnum, isOptional: false },
-    transformExpression: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: true
-    },
-    lookupConfig: { type: ScalarTypeEnum.JSON(), isOptional: true },
-    constantValue: { type: ScalarTypeEnum.JSON(), isOptional: true },
-    isRequired: { type: ScalarTypeEnum.Boolean(), isOptional: true },
-    defaultValue: { type: ScalarTypeEnum.JSON(), isOptional: true }
-  }
-});
-var TriggerSyncInputModel = defineSchemaModel({
-  name: "TriggerSyncInput",
-  fields: {
-    syncConfigId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    direction: { type: SyncDirectionEnum, isOptional: true },
-    fullSync: { type: ScalarTypeEnum.Boolean(), isOptional: true }
-  }
-});
-var ListSyncRunsInputModel = defineSchemaModel({
-  name: "ListSyncRunsInput",
-  fields: {
-    syncConfigId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    status: { type: SyncStatusEnum, isOptional: true },
-    limit: {
-      type: ScalarTypeEnum.Int_unsecure(),
-      isOptional: true,
-      defaultValue: 20
-    },
-    offset: {
-      type: ScalarTypeEnum.Int_unsecure(),
-      isOptional: true,
-      defaultValue: 0
-    }
-  }
-});
-var ListSyncRunsOutputModel = defineSchemaModel({
-  name: "ListSyncRunsOutput",
-  fields: {
-    runs: { type: SyncRunModel, isArray: true, isOptional: false },
-    total: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false }
-  }
-});
-
-// src/sync/sync.presentation.ts
-import {
-  definePresentation,
-  StabilityEnum
-} from "@contractspec/lib.contracts-spec";
-var SyncConfigListPresentation = definePresentation({
-  meta: {
-    key: "integration.syncConfig.list",
-    version: "1.0.0",
-    title: "Sync Config List",
-    description: "List of sync configurations",
-    domain: "integration",
-    owners: ["@integration-team"],
-    tags: ["integration", "sync", "config", "list"],
-    stability: StabilityEnum.Experimental,
-    goal: "Show users their current sync configurations.",
-    context: "Management view for data synchronization."
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "SyncConfigList",
-    props: SyncConfigModel
-  },
-  targets: ["react", "markdown"],
-  policy: {
-    flags: ["integration.sync.enabled"]
-  }
-});
-var SyncConfigEditorPresentation = definePresentation({
-  meta: {
-    key: "integration.syncConfig.editor",
-    version: "1.0.0",
-    title: "Sync Config Editor",
-    description: "Editor for sync configuration settings",
-    domain: "integration",
-    owners: ["@integration-team"],
-    tags: ["integration", "sync", "config", "editor"],
-    stability: StabilityEnum.Experimental,
-    goal: "Allow users to configure schedule, filters, and settings for a sync.",
-    context: "Configuration interface for sync jobs."
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "SyncConfigEditor",
-    props: SyncConfigModel
-  },
-  targets: ["react"],
-  policy: {
-    flags: ["integration.sync.enabled"]
-  }
-});
-var FieldMappingEditorPresentation = definePresentation({
-  meta: {
-    key: "integration.fieldMapping.editor",
-    version: "1.0.0",
-    title: "Field Mapping Editor",
-    description: "Visual field mapping editor",
-    domain: "integration",
-    owners: ["@integration-team"],
-    tags: ["integration", "field-mapping", "editor"],
-    stability: StabilityEnum.Experimental,
-    goal: "Allow users to map source fields to target fields visually.",
-    context: "Schema mapping tool for data consistency."
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "FieldMappingEditor",
-    props: FieldMappingModel
-  },
-  targets: ["react"],
-  policy: {
-    flags: ["integration.sync.enabled"]
-  }
-});
-var SyncRunListPresentation = definePresentation({
-  meta: {
-    key: "integration.syncRun.viewList",
-    version: "1.0.0",
-    title: "Sync Run History",
-    description: "History of sync runs",
-    domain: "integration",
-    owners: ["@integration-team"],
-    tags: ["integration", "sync", "runs", "history"],
-    stability: StabilityEnum.Experimental,
-    goal: "Provide a historical log of all sync attempts and their results.",
-    context: "Audit and troubleshooting view for sync jobs."
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "SyncRunList",
-    props: SyncRunModel
-  },
-  targets: ["react", "markdown"],
-  policy: {
-    flags: ["integration.sync.enabled"]
-  }
-});
-var SyncRunDetailPresentation = definePresentation({
-  meta: {
-    key: "integration.syncRun.detail",
-    version: "1.0.0",
-    title: "Sync Run Details",
-    description: "Detailed view of a sync run with logs",
-    domain: "integration",
-    owners: ["@integration-team"],
-    tags: ["integration", "sync", "run", "detail"],
-    stability: StabilityEnum.Experimental,
-    goal: "Show granular details and logs for a specific sync run.",
-    context: "Detailed troubleshooting view."
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "SyncRunDetail",
-    props: SyncRunModel
-  },
-  targets: ["react", "markdown"],
-  policy: {
-    flags: ["integration.sync.enabled"]
-  }
-});
-var SyncActivityPresentation = definePresentation({
-  meta: {
-    key: "integration.sync.activity",
-    version: "1.0.0",
-    title: "Sync Activity Monitor",
-    description: "Real-time sync activity monitor",
-    domain: "integration",
-    owners: ["@integration-team"],
-    tags: ["integration", "sync", "activity", "realtime"],
-    stability: StabilityEnum.Experimental,
-    goal: "Monitor live data flow and sync performance.",
-    context: "Real-time operations monitor."
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "SyncActivity"
-  },
-  targets: ["react", "markdown"],
-  policy: {
-    flags: ["integration.sync.enabled"]
-  }
-});
-export {
-  SyncRunListPresentation,
-  SyncRunDetailPresentation,
-  SyncConfigListPresentation,
-  SyncConfigEditorPresentation,
-  SyncActivityPresentation,
-  FieldMappingEditorPresentation
-};

package/dist/browser/sync/sync.schema.js

@@ -1,154 +0,0 @@
-// src/sync/sync.enum.ts
-import { defineEnum } from "@contractspec/lib.schema";
-var SyncDirectionEnum = defineEnum("SyncDirection", [
-  "INBOUND",
-  "OUTBOUND",
-  "BIDIRECTIONAL"
-]);
-var SyncStatusEnum = defineEnum("SyncStatus", [
-  "PENDING",
-  "RUNNING",
-  "COMPLETED",
-  "FAILED",
-  "CANCELLED"
-]);
-var MappingTypeEnum = defineEnum("MappingType", [
-  "DIRECT",
-  "TRANSFORM",
-  "LOOKUP",
-  "CONSTANT",
-  "COMPUTED"
-]);
-
-// src/sync/sync.schema.ts
-import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
-var FieldMappingModel = defineSchemaModel({
-  name: "FieldMappingModel",
-  fields: {
-    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    sourceField: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    targetField: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    mappingType: { type: MappingTypeEnum, isOptional: false },
-    transformExpression: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: true
-    },
-    isRequired: { type: ScalarTypeEnum.Boolean(), isOptional: false }
-  }
-});
-var SyncConfigModel = defineSchemaModel({
-  name: "SyncConfigModel",
-  fields: {
-    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    integrationId: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false
-    },
-    connectionId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    direction: { type: SyncDirectionEnum, isOptional: false },
-    sourceObject: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    targetObject: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    scheduleEnabled: { type: ScalarTypeEnum.Boolean(), isOptional: false },
-    scheduleCron: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    isActive: { type: ScalarTypeEnum.Boolean(), isOptional: false },
-    lastSyncAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
-    fieldMappings: { type: FieldMappingModel, isArray: true, isOptional: true }
-  }
-});
-var SyncRunModel = defineSchemaModel({
-  name: "SyncRunModel",
-  fields: {
-    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    syncConfigId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    status: { type: SyncStatusEnum, isOptional: false },
-    direction: { type: SyncDirectionEnum, isOptional: false },
-    trigger: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    recordsProcessed: {
-      type: ScalarTypeEnum.Int_unsecure(),
-      isOptional: false
-    },
-    recordsCreated: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    recordsUpdated: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    recordsFailed: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    errorMessage: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    startedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
-    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
-    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
-  }
-});
-var CreateSyncConfigInputModel = defineSchemaModel({
-  name: "CreateSyncConfigInput",
-  fields: {
-    integrationId: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false
-    },
-    connectionId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
-    direction: { type: SyncDirectionEnum, isOptional: false },
-    sourceObject: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
-    targetObject: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
-    scheduleEnabled: { type: ScalarTypeEnum.Boolean(), isOptional: true },
-    scheduleCron: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
-  }
-});
-var AddFieldMappingInputModel = defineSchemaModel({
-  name: "AddFieldMappingInput",
-  fields: {
-    syncConfigId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    sourceField: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
-    targetField: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
-    mappingType: { type: MappingTypeEnum, isOptional: false },
-    transformExpression: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: true
-    },
-    lookupConfig: { type: ScalarTypeEnum.JSON(), isOptional: true },
-    constantValue: { type: ScalarTypeEnum.JSON(), isOptional: true },
-    isRequired: { type: ScalarTypeEnum.Boolean(), isOptional: true },
-    defaultValue: { type: ScalarTypeEnum.JSON(), isOptional: true }
-  }
-});
-var TriggerSyncInputModel = defineSchemaModel({
-  name: "TriggerSyncInput",
-  fields: {
-    syncConfigId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    direction: { type: SyncDirectionEnum, isOptional: true },
-    fullSync: { type: ScalarTypeEnum.Boolean(), isOptional: true }
-  }
-});
-var ListSyncRunsInputModel = defineSchemaModel({
-  name: "ListSyncRunsInput",
-  fields: {
-    syncConfigId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    status: { type: SyncStatusEnum, isOptional: true },
-    limit: {
-      type: ScalarTypeEnum.Int_unsecure(),
-      isOptional: true,
-      defaultValue: 20
-    },
-    offset: {
-      type: ScalarTypeEnum.Int_unsecure(),
-      isOptional: true,
-      defaultValue: 0
-    }
-  }
-});
-var ListSyncRunsOutputModel = defineSchemaModel({
-  name: "ListSyncRunsOutput",
-  fields: {
-    runs: { type: SyncRunModel, isArray: true, isOptional: false },
-    total: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false }
-  }
-});
-export {
-  TriggerSyncInputModel,
-  SyncRunModel,
-  SyncConfigModel,
-  ListSyncRunsOutputModel,
-  ListSyncRunsInputModel,
-  FieldMappingModel,
-  CreateSyncConfigInputModel,
-  AddFieldMappingInputModel
-};

package/dist/browser/sync-engine/index.js

@@ -1,186 +0,0 @@
-// src/sync-engine/index.ts
-class BasicFieldTransformer {
-  transform(value, expression) {
-    try {
-      if (expression.startsWith("uppercase")) {
-        return typeof value === "string" ? value.toUpperCase() : value;
-      }
-      if (expression.startsWith("lowercase")) {
-        return typeof value === "string" ? value.toLowerCase() : value;
-      }
-      if (expression.startsWith("trim")) {
-        return typeof value === "string" ? value.trim() : value;
-      }
-      if (expression.startsWith("default:")) {
-        const defaultVal = expression.replace("default:", "");
-        return value ?? JSON.parse(defaultVal);
-      }
-      if (expression.startsWith("concat:")) {
-        const separator = expression.replace("concat:", "") || " ";
-        if (Array.isArray(value)) {
-          return value.join(separator);
-        }
-        return value;
-      }
-      if (expression.startsWith("split:")) {
-        const separator = expression.replace("split:", "") || ",";
-        if (typeof value === "string") {
-          return value.split(separator);
-        }
-        return value;
-      }
-      if (expression.startsWith("number")) {
-        return Number(value);
-      }
-      if (expression.startsWith("boolean")) {
-        return Boolean(value);
-      }
-      if (expression.startsWith("string")) {
-        return String(value);
-      }
-      return value;
-    } catch {
-      return value;
-    }
-  }
-}
-
-class BasicSyncEngine {
-  transformer;
-  constructor(transformer) {
-    this.transformer = transformer ?? new BasicFieldTransformer;
-  }
-  async sync(_context) {
-    const result = {
-      success: true,
-      recordsProcessed: 0,
-      recordsCreated: 0,
-      recordsUpdated: 0,
-      recordsDeleted: 0,
-      recordsFailed: 0,
-      recordsSkipped: 0,
-      errors: []
-    };
-    return result;
-  }
-  transformRecord(sourceRecord, mappings, _context) {
-    const targetData = {};
-    for (const mapping of mappings) {
-      let value;
-      let sourceValue;
-      switch (mapping.mappingType) {
-        case "DIRECT":
-          value = this.getNestedValue(sourceRecord.data, mapping.sourceField);
-          break;
-        case "TRANSFORM":
-          sourceValue = this.getNestedValue(sourceRecord.data, mapping.sourceField);
-          value = mapping.transformExpression ? this.transformer.transform(sourceValue, mapping.transformExpression) : sourceValue;
-          break;
-        case "CONSTANT":
-          value = mapping.constantValue;
-          break;
-        case "LOOKUP":
-          value = this.getNestedValue(sourceRecord.data, mapping.sourceField);
-          break;
-        case "COMPUTED":
-          value = mapping.transformExpression ? this.evaluateComputed(sourceRecord.data, mapping.transformExpression) : null;
-          break;
-        default:
-          value = this.getNestedValue(sourceRecord.data, mapping.sourceField);
-      }
-      if (value === undefined || value === null) {
-        value = mapping.defaultValue;
-      }
-      this.setNestedValue(targetData, mapping.targetField, value);
-    }
-    return {
-      id: sourceRecord.id,
-      data: targetData
-    };
-  }
-  validateRecord(record, mappings) {
-    const errors = [];
-    for (const mapping of mappings) {
-      if (mapping.isRequired) {
-        const value = this.getNestedValue(record.data, mapping.targetField);
-        if (value === undefined || value === null) {
-          errors.push({
-            recordId: record.id,
-            field: mapping.targetField,
-            message: `Required field ${mapping.targetField} is missing`,
-            code: "REQUIRED_FIELD_MISSING"
-          });
-        }
-      }
-    }
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-  getNestedValue(obj, path) {
-    const parts = path.split(".");
-    let current = obj;
-    for (const part of parts) {
-      if (current === null || current === undefined) {
-        return;
-      }
-      current = current[part];
-    }
-    return current;
-  }
-  setNestedValue(obj, path, value) {
-    const parts = path.split(".");
-    let current = obj;
-    for (let i = 0;i < parts.length - 1; i++) {
-      const part = parts[i];
-      if (part === undefined)
-        continue;
-      if (!(part in current)) {
-        current[part] = {};
-      }
-      current = current[part];
-    }
-    const lastPart = parts[parts.length - 1];
-    if (lastPart !== undefined) {
-      current[lastPart] = value;
-    }
-  }
-  evaluateComputed(data, expression) {
-    try {
-      const result = expression.replace(/\$\{([^}]+)\}/g, (_, path) => {
-        const value = this.getNestedValue(data, path);
-        return String(value ?? "");
-      });
-      return result;
-    } catch {
-      return null;
-    }
-  }
-}
-function createSyncEngine(transformer) {
-  return new BasicSyncEngine(transformer);
-}
-function computeChecksum(data) {
-  const str = JSON.stringify(data, Object.keys(data).sort());
-  let hash = 0;
-  for (let i = 0;i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash = hash & hash;
-  }
-  return hash.toString(16);
-}
-function hasChanges(sourceChecksum, targetChecksum) {
-  if (!sourceChecksum || !targetChecksum) {
-    return true;
-  }
-  return sourceChecksum !== targetChecksum;
-}
-export {
-  hasChanges,
-  createSyncEngine,
-  computeChecksum,
-  BasicSyncEngine,
-  BasicFieldTransformer
-};