cdk-dms-replication 0.0.0

package/lib/table-mappings.js

@@ -0,0 +1,283 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableMappings = exports.ColumnDataType = exports.RuleObjectLocator = exports.TransformationAction = exports.SelectionAction = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Table mappings define which schemas/tables DMS migrates and how they are
+ * transformed. This builder produces the JSON string that DMS expects for
+ * the `tableMappings` property of a replication task.
+ *
+ * @see https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.html
+ */
+// ---------------------------------------------------------------------------
+// Enums
+// ---------------------------------------------------------------------------
+/** Whether the rule selects or excludes objects. */
+var SelectionAction;
+(function (SelectionAction) {
+    SelectionAction["INCLUDE"] = "include";
+    SelectionAction["EXCLUDE"] = "exclude";
+    SelectionAction["EXPLICIT"] = "explicit";
+})(SelectionAction || (exports.SelectionAction = SelectionAction = {}));
+/** Table-level transformation actions. */
+var TransformationAction;
+(function (TransformationAction) {
+    /** Convert the name to lowercase. */
+    TransformationAction["CONVERT_LOWERCASE"] = "convert-lowercase";
+    /** Convert the name to uppercase. */
+    TransformationAction["CONVERT_UPPERCASE"] = "convert-uppercase";
+    /** Add a prefix to the name. */
+    TransformationAction["ADD_PREFIX"] = "add-prefix";
+    /** Remove a prefix from the name. */
+    TransformationAction["REMOVE_PREFIX"] = "remove-prefix";
+    /** Add a suffix to the name. */
+    TransformationAction["ADD_SUFFIX"] = "add-suffix";
+    /** Remove a suffix from the name. */
+    TransformationAction["REMOVE_SUFFIX"] = "remove-suffix";
+    /** Rename the object. */
+    TransformationAction["RENAME"] = "rename";
+    /** Remove the column. */
+    TransformationAction["REMOVE_COLUMN"] = "remove-column";
+    /** Add a column. */
+    TransformationAction["ADD_COLUMN"] = "add-column";
+    /** Include the column. */
+    TransformationAction["INCLUDE_COLUMN"] = "include-column";
+})(TransformationAction || (exports.TransformationAction = TransformationAction = {}));
+/** The object type a rule targets. */
+var RuleObjectLocator;
+(function (RuleObjectLocator) {
+    RuleObjectLocator["SCHEMA"] = "schema";
+    RuleObjectLocator["TABLE"] = "table";
+    RuleObjectLocator["COLUMN"] = "column";
+    RuleObjectLocator["TABLE_TABLESPACE"] = "table-tablespace";
+    RuleObjectLocator["INDEX_TABLESPACE"] = "index-tablespace";
+})(RuleObjectLocator || (exports.RuleObjectLocator = RuleObjectLocator = {}));
+/** Data type for added columns. */
+var ColumnDataType;
+(function (ColumnDataType) {
+    ColumnDataType["STRING"] = "string";
+    ColumnDataType["INT4"] = "int4";
+    ColumnDataType["INT8"] = "int8";
+    ColumnDataType["FLOAT4"] = "float4";
+    ColumnDataType["FLOAT8"] = "float8";
+    ColumnDataType["NUMERIC"] = "numeric";
+    ColumnDataType["DATETIME"] = "datetime";
+    ColumnDataType["BYTES"] = "bytes";
+    ColumnDataType["BLOB"] = "blob";
+})(ColumnDataType || (exports.ColumnDataType = ColumnDataType = {}));
+// ---------------------------------------------------------------------------
+// Builder
+// ---------------------------------------------------------------------------
+/**
+ * Fluent builder for DMS table mappings.
+ *
+ * @example
+ * const mappings = new TableMappings()
+ *   .includeSchema('public')
+ *   .includeTable('public', 'orders')
+ *   .excludeTable('public', 'audit_log')
+ *   .renameSchema('public', 'prod')
+ *   .toLowerCaseTable('public', '%')
+ *   .toJson();
+ */
+class TableMappings {
+    constructor() {
+        this.rules = [];
+        this.nextId = 1;
+    }
+    // -------------------------------------------------------------------------
+    // Selection rules
+    // -------------------------------------------------------------------------
+    /**
+     * Include all tables in a schema.
+     * Use `%` as a wildcard for `schemaName` to include all schemas.
+     */
+    includeSchema(schemaName) {
+        return this.addSelectionRule(schemaName, '%', SelectionAction.INCLUDE);
+    }
+    /** Exclude all tables in a schema. */
+    excludeSchema(schemaName) {
+        return this.addSelectionRule(schemaName, '%', SelectionAction.EXCLUDE);
+    }
+    /**
+     * Include a specific table (or a wildcard pattern) within a schema.
+     * Use `%` for `tableName` to match all tables in the schema.
+     */
+    includeTable(schemaName, tableName) {
+        return this.addSelectionRule(schemaName, tableName, SelectionAction.INCLUDE);
+    }
+    /** Exclude a specific table (or wildcard) within a schema. */
+    excludeTable(schemaName, tableName) {
+        return this.addSelectionRule(schemaName, tableName, SelectionAction.EXCLUDE);
+    }
+    /**
+     * Explicitly include a single table. Unlike `include`, `explicit` means DMS
+     * only migrates this one table regardless of other `include` rules.
+     */
+    explicitTable(schemaName, tableName) {
+        return this.addSelectionRule(schemaName, tableName, SelectionAction.EXPLICIT);
+    }
+    addSelectionRule(schemaName, tableName, action) {
+        const id = this.nextId++;
+        this.rules.push({
+            'rule-type': 'selection',
+            'rule-id': String(id),
+            'rule-name': `${id}`,
+            'object-locator': {
+                'schema-name': schemaName,
+                'table-name': tableName,
+            },
+            'rule-action': action,
+        });
+        return this;
+    }
+    // -------------------------------------------------------------------------
+    // Transformation rules — schema
+    // -------------------------------------------------------------------------
+    /** Rename a schema. */
+    renameSchema(schemaName, newName) {
+        return this.addTransformationRule(schemaName, '%', undefined, RuleObjectLocator.SCHEMA, TransformationAction.RENAME, newName);
+    }
+    /** Convert all schema names to lowercase. */
+    toLowerCaseSchema(schemaName) {
+        return this.addTransformationRule(schemaName, '%', undefined, RuleObjectLocator.SCHEMA, TransformationAction.CONVERT_LOWERCASE);
+    }
+    /** Convert all schema names to uppercase. */
+    toUpperCaseSchema(schemaName) {
+        return this.addTransformationRule(schemaName, '%', undefined, RuleObjectLocator.SCHEMA, TransformationAction.CONVERT_UPPERCASE);
+    }
+    /** Add a prefix to schema names. */
+    addPrefixToSchema(schemaName, prefix) {
+        return this.addTransformationRule(schemaName, '%', undefined, RuleObjectLocator.SCHEMA, TransformationAction.ADD_PREFIX, prefix);
+    }
+    /** Add a suffix to schema names. */
+    addSuffixToSchema(schemaName, suffix) {
+        return this.addTransformationRule(schemaName, '%', undefined, RuleObjectLocator.SCHEMA, TransformationAction.ADD_SUFFIX, suffix);
+    }
+    // -------------------------------------------------------------------------
+    // Transformation rules — table
+    // -------------------------------------------------------------------------
+    /** Rename a table. */
+    renameTable(schemaName, tableName, newName) {
+        return this.addTransformationRule(schemaName, tableName, undefined, RuleObjectLocator.TABLE, TransformationAction.RENAME, newName);
+    }
+    /** Convert matching table names to lowercase. Use `%` to match all tables. */
+    toLowerCaseTable(schemaName, tableName) {
+        return this.addTransformationRule(schemaName, tableName, undefined, RuleObjectLocator.TABLE, TransformationAction.CONVERT_LOWERCASE);
+    }
+    /** Convert matching table names to uppercase. */
+    toUpperCaseTable(schemaName, tableName) {
+        return this.addTransformationRule(schemaName, tableName, undefined, RuleObjectLocator.TABLE, TransformationAction.CONVERT_UPPERCASE);
+    }
+    /** Add a prefix to table names. */
+    addPrefixToTable(schemaName, tableName, prefix) {
+        return this.addTransformationRule(schemaName, tableName, undefined, RuleObjectLocator.TABLE, TransformationAction.ADD_PREFIX, prefix);
+    }
+    /** Add a suffix to table names. */
+    addSuffixToTable(schemaName, tableName, suffix) {
+        return this.addTransformationRule(schemaName, tableName, undefined, RuleObjectLocator.TABLE, TransformationAction.ADD_SUFFIX, suffix);
+    }
+    // -------------------------------------------------------------------------
+    // Transformation rules — column
+    // -------------------------------------------------------------------------
+    /** Rename a column in a table. */
+    renameColumn(schemaName, tableName, columnName, newName) {
+        return this.addTransformationRule(schemaName, tableName, columnName, RuleObjectLocator.COLUMN, TransformationAction.RENAME, newName);
+    }
+    /** Convert matching column names to lowercase. */
+    toLowerCaseColumn(schemaName, tableName, columnName) {
+        return this.addTransformationRule(schemaName, tableName, columnName, RuleObjectLocator.COLUMN, TransformationAction.CONVERT_LOWERCASE);
+    }
+    /** Convert matching column names to uppercase. */
+    toUpperCaseColumn(schemaName, tableName, columnName) {
+        return this.addTransformationRule(schemaName, tableName, columnName, RuleObjectLocator.COLUMN, TransformationAction.CONVERT_UPPERCASE);
+    }
+    /** Remove a column from a table. */
+    removeColumn(schemaName, tableName, columnName) {
+        return this.addTransformationRule(schemaName, tableName, columnName, RuleObjectLocator.COLUMN, TransformationAction.REMOVE_COLUMN);
+    }
+    /**
+     * Add a new column to a table.
+     *
+     * @example
+     * mappings.addColumn('public', 'orders', {
+     *   columnName: 'migration_ts',
+     *   columnType: ColumnDataType.DATETIME,
+     *   expression: '$timestamp',
+     * });
+     */
+    addColumn(schemaName, tableName, column) {
+        const id = this.nextId++;
+        const objectLocator = {
+            'schema-name': schemaName,
+            'table-name': tableName,
+        };
+        const rule = {
+            'rule-type': 'transformation',
+            'rule-id': String(id),
+            'rule-name': `${id}`,
+            'object-locator': objectLocator,
+            'rule-action': TransformationAction.ADD_COLUMN,
+            'rule-target': 'column',
+            'value': column.columnName,
+            'data-type': this.buildDataType(column),
+        };
+        if (column.expression) {
+            rule.expression = column.expression;
+        }
+        else if (column.columnValue !== undefined) {
+            rule.value = column.columnValue;
+        }
+        this.rules.push(rule);
+        return this;
+    }
+    buildDataType(column) {
+        const dt = { type: column.columnType };
+        if (column.columnLength !== undefined)
+            dt.length = column.columnLength;
+        if (column.columnPrecision !== undefined)
+            dt.precision = column.columnPrecision;
+        if (column.columnScale !== undefined)
+            dt.scale = column.columnScale;
+        return dt;
+    }
+    addTransformationRule(schemaName, tableName, columnName, ruleTarget, action, value) {
+        const id = this.nextId++;
+        const objectLocator = {
+            'schema-name': schemaName,
+            'table-name': tableName,
+        };
+        if (columnName !== undefined) {
+            objectLocator['column-name'] = columnName;
+        }
+        const rule = {
+            'rule-type': 'transformation',
+            'rule-id': String(id),
+            'rule-name': `${id}`,
+            'rule-target': ruleTarget,
+            'object-locator': objectLocator,
+            'rule-action': action,
+        };
+        if (value !== undefined) {
+            rule.value = value;
+        }
+        this.rules.push(rule);
+        return this;
+    }
+    // -------------------------------------------------------------------------
+    // Output
+    // -------------------------------------------------------------------------
+    /**
+     * Serialise the accumulated rules to the JSON string expected by DMS.
+     * Passes the result directly to `replicationTaskSettings` or
+     * `DmsReplicationTask.tableMappings`.
+     */
+    toJson() {
+        return JSON.stringify({ rules: this.rules }, null, 2);
+    }
+}
+exports.TableMappings = TableMappings;
+_a = JSII_RTTI_SYMBOL_1;
+TableMappings[_a] = { fqn: "cdk-dms-replication.TableMappings", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-mappings.js","sourceRoot":"","sources":["../src/table-mappings.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Table mappings define which schemas/tables DMS migrates and how they are\n * transformed. This builder produces the JSON string that DMS expects for\n * the `tableMappings` property of a replication task.\n *\n * @see https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.html\n */\n\n// ---------------------------------------------------------------------------\n// Enums\n// ---------------------------------------------------------------------------\n\n/** Whether the rule selects or excludes objects. */\nexport enum SelectionAction {\n  INCLUDE = 'include',\n  EXCLUDE = 'exclude',\n  EXPLICIT = 'explicit',\n}\n\n/** Table-level transformation actions. */\nexport enum TransformationAction {\n  /** Convert the name to lowercase. */\n  CONVERT_LOWERCASE = 'convert-lowercase',\n  /** Convert the name to uppercase. */\n  CONVERT_UPPERCASE = 'convert-uppercase',\n  /** Add a prefix to the name. */\n  ADD_PREFIX = 'add-prefix',\n  /** Remove a prefix from the name. */\n  REMOVE_PREFIX = 'remove-prefix',\n  /** Add a suffix to the name. */\n  ADD_SUFFIX = 'add-suffix',\n  /** Remove a suffix from the name. */\n  REMOVE_SUFFIX = 'remove-suffix',\n  /** Rename the object. */\n  RENAME = 'rename',\n  /** Remove the column. */\n  REMOVE_COLUMN = 'remove-column',\n  /** Add a column. */\n  ADD_COLUMN = 'add-column',\n  /** Include the column. */\n  INCLUDE_COLUMN = 'include-column',\n}\n\n/** The object type a rule targets. */\nexport enum RuleObjectLocator {\n  SCHEMA = 'schema',\n  TABLE = 'table',\n  COLUMN = 'column',\n  TABLE_TABLESPACE = 'table-tablespace',\n  INDEX_TABLESPACE = 'index-tablespace',\n}\n\n/** Data type for added columns. */\nexport enum ColumnDataType {\n  STRING = 'string',\n  INT4 = 'int4',\n  INT8 = 'int8',\n  FLOAT4 = 'float4',\n  FLOAT8 = 'float8',\n  NUMERIC = 'numeric',\n  DATETIME = 'datetime',\n  BYTES = 'bytes',\n  BLOB = 'blob',\n}\n\n// ---------------------------------------------------------------------------\n// Interfaces\n// ---------------------------------------------------------------------------\n\n/** A column added via an ADD_COLUMN transformation. */\nexport interface AddColumnDefinition {\n  /** Name of the new column. */\n  readonly columnName: string;\n  /** Data type of the new column. */\n  readonly columnType: ColumnDataType;\n  /** Character length for string columns. */\n  readonly columnLength?: number;\n  /** Precision for numeric columns. */\n  readonly columnPrecision?: number;\n  /** Scale for numeric columns. */\n  readonly columnScale?: number;\n  /**\n   * Constant value to populate the column with.\n   * Exactly one of `columnValue` or `expression` must be set.\n   */\n  readonly columnValue?: string;\n  /**\n   * Expression (e.g. `$timestamp`) to populate the column.\n   * Exactly one of `columnValue` or `expression` must be set.\n   */\n  readonly expression?: string;\n}\n\n/** Object locator identifying the schema, table, and optional column a rule targets. */\nexport interface RuleObjectLocatorValue {\n  readonly schemaName: string;\n  readonly tableName?: string;\n  readonly columnName?: string;\n}\n\n/** Represents a single, fully built rule in the table-mappings JSON. */\nexport interface TableMappingRule {\n  readonly ruleType: string;\n  readonly ruleId: string;\n  readonly ruleName: string;\n  readonly objectLocator: RuleObjectLocatorValue;\n  readonly ruleAction: string;\n  readonly value?: string;\n  readonly oldValue?: string;\n}\n\n// ---------------------------------------------------------------------------\n// Builder\n// ---------------------------------------------------------------------------\n\n/**\n * Fluent builder for DMS table mappings.\n *\n * @example\n * const mappings = new TableMappings()\n *   .includeSchema('public')\n *   .includeTable('public', 'orders')\n *   .excludeTable('public', 'audit_log')\n *   .renameSchema('public', 'prod')\n *   .toLowerCaseTable('public', '%')\n *   .toJson();\n */\nexport class TableMappings {\n  private readonly rules: Record<string, unknown>[] = [];\n  private nextId: number = 1;\n\n  // -------------------------------------------------------------------------\n  // Selection rules\n  // -------------------------------------------------------------------------\n\n  /**\n   * Include all tables in a schema.\n   * Use `%` as a wildcard for `schemaName` to include all schemas.\n   */\n  includeSchema(schemaName: string): TableMappings {\n    return this.addSelectionRule(schemaName, '%', SelectionAction.INCLUDE);\n  }\n\n  /** Exclude all tables in a schema. */\n  excludeSchema(schemaName: string): TableMappings {\n    return this.addSelectionRule(schemaName, '%', SelectionAction.EXCLUDE);\n  }\n\n  /**\n   * Include a specific table (or a wildcard pattern) within a schema.\n   * Use `%` for `tableName` to match all tables in the schema.\n   */\n  includeTable(schemaName: string, tableName: string): TableMappings {\n    return this.addSelectionRule(schemaName, tableName, SelectionAction.INCLUDE);\n  }\n\n  /** Exclude a specific table (or wildcard) within a schema. */\n  excludeTable(schemaName: string, tableName: string): TableMappings {\n    return this.addSelectionRule(schemaName, tableName, SelectionAction.EXCLUDE);\n  }\n\n  /**\n   * Explicitly include a single table. Unlike `include`, `explicit` means DMS\n   * only migrates this one table regardless of other `include` rules.\n   */\n  explicitTable(schemaName: string, tableName: string): TableMappings {\n    return this.addSelectionRule(schemaName, tableName, SelectionAction.EXPLICIT);\n  }\n\n  private addSelectionRule(\n    schemaName: string,\n    tableName: string,\n    action: SelectionAction,\n  ): TableMappings {\n    const id = this.nextId++;\n    this.rules.push({\n      'rule-type': 'selection',\n      'rule-id': String(id),\n      'rule-name': `${id}`,\n      'object-locator': {\n        'schema-name': schemaName,\n        'table-name': tableName,\n      },\n      'rule-action': action,\n    });\n    return this;\n  }\n\n  // -------------------------------------------------------------------------\n  // Transformation rules — schema\n  // -------------------------------------------------------------------------\n\n  /** Rename a schema. */\n  renameSchema(schemaName: string, newName: string): TableMappings {\n    return this.addTransformationRule(\n      schemaName,\n      '%',\n      undefined,\n      RuleObjectLocator.SCHEMA,\n      TransformationAction.RENAME,\n      newName,\n    );\n  }\n\n  /** Convert all schema names to lowercase. */\n  toLowerCaseSchema(schemaName: string): TableMappings {\n    return this.addTransformationRule(\n      schemaName,\n      '%',\n      undefined,\n      RuleObjectLocator.SCHEMA,\n      TransformationAction.CONVERT_LOWERCASE,\n    );\n  }\n\n  /** Convert all schema names to uppercase. */\n  toUpperCaseSchema(schemaName: string): TableMappings {\n    return this.addTransformationRule(\n      schemaName,\n      '%',\n      undefined,\n      RuleObjectLocator.SCHEMA,\n      TransformationAction.CONVERT_UPPERCASE,\n    );\n  }\n\n  /** Add a prefix to schema names. */\n  addPrefixToSchema(schemaName: string, prefix: string): TableMappings {\n    return this.addTransformationRule(\n      schemaName,\n      '%',\n      undefined,\n      RuleObjectLocator.SCHEMA,\n      TransformationAction.ADD_PREFIX,\n      prefix,\n    );\n  }\n\n  /** Add a suffix to schema names. */\n  addSuffixToSchema(schemaName: string, suffix: string): TableMappings {\n    return this.addTransformationRule(\n      schemaName,\n      '%',\n      undefined,\n      RuleObjectLocator.SCHEMA,\n      TransformationAction.ADD_SUFFIX,\n      suffix,\n    );\n  }\n\n  // -------------------------------------------------------------------------\n  // Transformation rules — table\n  // -------------------------------------------------------------------------\n\n  /** Rename a table. */\n  renameTable(schemaName: string, tableName: string, newName: string): TableMappings {\n    return this.addTransformationRule(\n      schemaName,\n      tableName,\n      undefined,\n      RuleObjectLocator.TABLE,\n      TransformationAction.RENAME,\n      newName,\n    );\n  }\n\n  /** Convert matching table names to lowercase. Use `%` to match all tables. */\n  toLowerCaseTable(schemaName: string, tableName: string): TableMappings {\n    return this.addTransformationRule(\n      schemaName,\n      tableName,\n      undefined,\n      RuleObjectLocator.TABLE,\n      TransformationAction.CONVERT_LOWERCASE,\n    );\n  }\n\n  /** Convert matching table names to uppercase. */\n  toUpperCaseTable(schemaName: string, tableName: string): TableMappings {\n    return this.addTransformationRule(\n      schemaName,\n      tableName,\n      undefined,\n      RuleObjectLocator.TABLE,\n      TransformationAction.CONVERT_UPPERCASE,\n    );\n  }\n\n  /** Add a prefix to table names. */\n  addPrefixToTable(schemaName: string, tableName: string, prefix: string): TableMappings {\n    return this.addTransformationRule(\n      schemaName,\n      tableName,\n      undefined,\n      RuleObjectLocator.TABLE,\n      TransformationAction.ADD_PREFIX,\n      prefix,\n    );\n  }\n\n  /** Add a suffix to table names. */\n  addSuffixToTable(schemaName: string, tableName: string, suffix: string): TableMappings {\n    return this.addTransformationRule(\n      schemaName,\n      tableName,\n      undefined,\n      RuleObjectLocator.TABLE,\n      TransformationAction.ADD_SUFFIX,\n      suffix,\n    );\n  }\n\n  // -------------------------------------------------------------------------\n  // Transformation rules — column\n  // -------------------------------------------------------------------------\n\n  /** Rename a column in a table. */\n  renameColumn(\n    schemaName: string,\n    tableName: string,\n    columnName: string,\n    newName: string,\n  ): TableMappings {\n    return this.addTransformationRule(\n      schemaName,\n      tableName,\n      columnName,\n      RuleObjectLocator.COLUMN,\n      TransformationAction.RENAME,\n      newName,\n    );\n  }\n\n  /** Convert matching column names to lowercase. */\n  toLowerCaseColumn(\n    schemaName: string,\n    tableName: string,\n    columnName: string,\n  ): TableMappings {\n    return this.addTransformationRule(\n      schemaName,\n      tableName,\n      columnName,\n      RuleObjectLocator.COLUMN,\n      TransformationAction.CONVERT_LOWERCASE,\n    );\n  }\n\n  /** Convert matching column names to uppercase. */\n  toUpperCaseColumn(\n    schemaName: string,\n    tableName: string,\n    columnName: string,\n  ): TableMappings {\n    return this.addTransformationRule(\n      schemaName,\n      tableName,\n      columnName,\n      RuleObjectLocator.COLUMN,\n      TransformationAction.CONVERT_UPPERCASE,\n    );\n  }\n\n  /** Remove a column from a table. */\n  removeColumn(\n    schemaName: string,\n    tableName: string,\n    columnName: string,\n  ): TableMappings {\n    return this.addTransformationRule(\n      schemaName,\n      tableName,\n      columnName,\n      RuleObjectLocator.COLUMN,\n      TransformationAction.REMOVE_COLUMN,\n    );\n  }\n\n  /**\n   * Add a new column to a table.\n   *\n   * @example\n   * mappings.addColumn('public', 'orders', {\n   *   columnName: 'migration_ts',\n   *   columnType: ColumnDataType.DATETIME,\n   *   expression: '$timestamp',\n   * });\n   */\n  addColumn(\n    schemaName: string,\n    tableName: string,\n    column: AddColumnDefinition,\n  ): TableMappings {\n    const id = this.nextId++;\n    const objectLocator: Record<string, string> = {\n      'schema-name': schemaName,\n      'table-name': tableName,\n    };\n\n    const rule: Record<string, unknown> = {\n      'rule-type': 'transformation',\n      'rule-id': String(id),\n      'rule-name': `${id}`,\n      'object-locator': objectLocator,\n      'rule-action': TransformationAction.ADD_COLUMN,\n      'rule-target': 'column',\n      'value': column.columnName,\n      'data-type': this.buildDataType(column),\n    };\n\n    if (column.expression) {\n      rule.expression = column.expression;\n    } else if (column.columnValue !== undefined) {\n      rule.value = column.columnValue;\n    }\n\n    this.rules.push(rule);\n    return this;\n  }\n\n  private buildDataType(column: AddColumnDefinition): Record<string, unknown> {\n    const dt: Record<string, unknown> = { type: column.columnType };\n    if (column.columnLength !== undefined) dt.length = column.columnLength;\n    if (column.columnPrecision !== undefined) dt.precision = column.columnPrecision;\n    if (column.columnScale !== undefined) dt.scale = column.columnScale;\n    return dt;\n  }\n\n  private addTransformationRule(\n    schemaName: string,\n    tableName: string,\n    columnName: string | undefined,\n    ruleTarget: RuleObjectLocator,\n    action: TransformationAction,\n    value?: string,\n  ): TableMappings {\n    const id = this.nextId++;\n    const objectLocator: Record<string, string> = {\n      'schema-name': schemaName,\n      'table-name': tableName,\n    };\n    if (columnName !== undefined) {\n      objectLocator['column-name'] = columnName;\n    }\n\n    const rule: Record<string, unknown> = {\n      'rule-type': 'transformation',\n      'rule-id': String(id),\n      'rule-name': `${id}`,\n      'rule-target': ruleTarget,\n      'object-locator': objectLocator,\n      'rule-action': action,\n    };\n    if (value !== undefined) {\n      rule.value = value;\n    }\n\n    this.rules.push(rule);\n    return this;\n  }\n\n  // -------------------------------------------------------------------------\n  // Output\n  // -------------------------------------------------------------------------\n\n  /**\n   * Serialise the accumulated rules to the JSON string expected by DMS.\n   * Passes the result directly to `replicationTaskSettings` or\n   * `DmsReplicationTask.tableMappings`.\n   */\n  toJson(): string {\n    return JSON.stringify({ rules: this.rules }, null, 2);\n  }\n}\n"]}

package/lib/task-settings.d.ts

@@ -0,0 +1,228 @@
+/**
+ * Builder for DMS replication task settings.
+ *
+ * The DMS task settings JSON controls logging, LOB handling, error handling,
+ * full-load tuning, and CDC tuning. This builder exposes the most commonly
+ * tuned knobs and produces the JSON string expected by a replication task.
+ *
+ * @see https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TaskSettings.html
+ */
+/** LOB (Large Object) handling mode. */
+export declare enum LobMode {
+    /** No LOB support. */
+    NONE = "none",
+    /** All LOBs are migrated as inline data (full LOB mode). */
+    FULL_LOB = "full-lob",
+    /** LOBs are truncated at a configurable size. */
+    LIMITED_LOB = "limited-lob"
+}
+/** Logging verbosity for DMS task log components. */
+export declare enum LoggingLevel {
+    LOGGER_SEVERITY_DEFAULT = "LOGGER_SEVERITY_DEFAULT",
+    LOGGER_SEVERITY_DEBUG = "LOGGER_SEVERITY_DEBUG",
+    LOGGER_SEVERITY_DETAILED_DEBUG = "LOGGER_SEVERITY_DETAILED_DEBUG",
+    LOGGER_SEVERITY_ERROR = "LOGGER_SEVERITY_ERROR",
+    LOGGER_SEVERITY_WARNING = "LOGGER_SEVERITY_WARNING"
+}
+/** Action to take on a recoverable error. */
+export declare enum ErrorAction {
+    /** Ignore the error and continue. */
+    IGNORE = "IGNORE",
+    /** Ignore the row, continue with the next. */
+    IGNORE_RECORD = "IGNORE_RECORD",
+    /** Stop the task. */
+    STOP_TASK = "STOP_TASK"
+}
+/** Logging configuration for a single DMS log component. */
+export interface LogComponentSettings {
+    /** Logging level for this component. */
+    readonly loggingLevel?: LoggingLevel;
+}
+/** Controls how the task handles full-load data. */
+export interface FullLoadSettings {
+    /**
+     * Maximum number of tables to load in parallel.
+     * @default 8
+     */
+    readonly maxFullLoadSubTasks?: number;
+    /**
+     * Number of rows to load before a commit.
+     * @default 10000
+     */
+    readonly transactionConsistencyTimeout?: number;
+    /**
+     * Whether to create target tables if they don't exist.
+     * @default true
+     */
+    readonly targetTablePrepMode?: string;
+    /**
+     * Whether to stop the task after the full load completes (only relevant for
+     * full-load tasks without CDC).
+     * @default false
+     */
+    readonly stopTaskCachedChangesApplied?: boolean;
+    /** Whether DMS commits the full load in a single transaction. */
+    readonly commitRate?: number;
+}
+/** Controls CDC behaviour. */
+export interface CdcSettings {
+    /**
+     * Offset in seconds from current time to use as the CDC start position.
+     * Ignored when `cdcStartPosition` is set on the task.
+     */
+    readonly enableTestMode?: boolean;
+    /**
+     * Whether DMS applies changes immediately (false) or batches them (true).
+     * @default false
+     */
+    readonly batchApplyEnabled?: boolean;
+    /**
+     * Number of seconds DMS waits before applying batched changes.
+     * Only relevant when `batchApplyEnabled` is true.
+     * @default 1
+     */
+    readonly batchApplyTimeoutMin?: number;
+    /**
+     * Maximum number of seconds DMS waits before applying batched changes.
+     * @default 30
+     */
+    readonly batchApplyTimeoutMax?: number;
+    /** Memory limit (in MB) for the apply task. @default 500 */
+    readonly batchApplyMemoryLimit?: number;
+    /** Whether to preserve transactions during CDC. @default true */
+    readonly failOnNoTablesCaptured?: boolean;
+}
+/** Controls error handling behaviour. */
+export interface ErrorHandlingSettings {
+    /**
+     * Action to take when DMS encounters a data error (e.g. duplicate key).
+     * @default ErrorAction.STOP_TASK
+     */
+    readonly dataErrorPolicy?: ErrorAction;
+    /**
+     * Maximum number of data errors before stopping.
+     * @default 0 (unlimited)
+     */
+    readonly dataErrorEscalationCount?: number;
+    /**
+     * Action to take after `dataErrorEscalationCount` errors are hit.
+     * @default ErrorAction.STOP_TASK
+     */
+    readonly dataErrorEscalationPolicy?: ErrorAction;
+    /**
+     * Action when DMS encounters a table error.
+     * @default ErrorAction.STOP_TASK
+     */
+    readonly tableErrorPolicy?: ErrorAction;
+    /**
+     * Maximum number of table errors before escalation.
+     * @default 0
+     */
+    readonly tableErrorEscalationCount?: number;
+    /**
+     * Action after `tableErrorEscalationCount` table errors.
+     * @default ErrorAction.STOP_TASK
+     */
+    readonly tableErrorEscalationPolicy?: ErrorAction;
+    /**
+     * Whether to recover from recoverable errors.
+     * @default true
+     */
+    readonly recoverableErrorCount?: number;
+    /**
+     * Interval in seconds between recovery attempts.
+     * @default 5
+     */
+    readonly recoverableErrorInterval?: number;
+    /**
+     * Throttle factor applied to recovery intervals.
+     * @default 2
+     */
+    readonly recoverableErrorThrottling?: boolean;
+    /**
+     * Maximum interval (seconds) between recovery attempts.
+     * @default 360
+     */
+    readonly recoverableErrorThrottlingMax?: number;
+}
+/**
+ * Fluent builder for DMS task settings.
+ *
+ * @example
+ * const settings = new TaskSettings()
+ *   .withLobMode(LobMode.LIMITED_LOB, 32)
+ *   .withFullLoadSubTasks(16)
+ *   .withBatchApply(true, 5, 60)
+ *   .withDataErrorPolicy(ErrorAction.IGNORE_RECORD, 100)
+ *   .withLogging('SOURCE_UNLOAD', LoggingLevel.LOGGER_SEVERITY_DEFAULT)
+ *   .toJson();
+ */
+export declare class TaskSettings {
+    private lobMode;
+    private lobMaxSize;
+    private fullLoadSettings;
+    private cdcSettings;
+    private errorHandlingSettings;
+    private loggingEnabled;
+    private logComponents;
+    /**
+     * Configure LOB handling.
+     *
+     * @param mode       How LOBs are handled.
+     * @param maxSizeKb  Maximum LOB size in KB when mode is LIMITED_LOB. Ignored otherwise.
+     */
+    withLobMode(mode: LobMode, maxSizeKb?: number): TaskSettings;
+    /**
+     * Set the maximum number of tables loaded in parallel.
+     * @param count Default 8.
+     */
+    withFullLoadSubTasks(count: number): TaskSettings;
+    /**
+     * Set the full-load target table prepare mode.
+     * Common values: "DROP_AND_CREATE", "TRUNCATE_BEFORE_LOAD", "DO_NOTHING".
+     */
+    withTargetTablePrepMode(mode: string): TaskSettings;
+    /**
+     * Set the commit rate (number of rows per commit) during full load.
+     */
+    withCommitRate(rows: number): TaskSettings;
+    /**
+     * Enable or disable CDC batch apply mode and configure its timeouts.
+     *
+     * @param enabled    Whether batch apply is on.
+     * @param minSeconds Minimum seconds before applying a batch (default 1).
+     * @param maxSeconds Maximum seconds before applying a batch (default 30).
+     */
+    withBatchApply(enabled: boolean, minSeconds?: number, maxSeconds?: number): TaskSettings;
+    /**
+     * Configure the action taken on data errors.
+     *
+     * @param policy         Action when a data error is encountered.
+     * @param escalationCount After this many errors, apply the escalation policy (0 = immediate).
+     * @param escalationPolicy Action after `escalationCount` errors.
+     */
+    withDataErrorPolicy(policy: ErrorAction, escalationCount?: number, escalationPolicy?: ErrorAction): TaskSettings;
+    /**
+     * Configure recovery from transient errors.
+     *
+     * @param count    Maximum recovery attempts (-1 = unlimited).
+     * @param interval Seconds between attempts.
+     */
+    withRecovery(count: number, interval?: number): TaskSettings;
+    /**
+     * Enable or disable CloudWatch logging for the task.
+     * @default true
+     */
+    withLoggingEnabled(enabled: boolean): TaskSettings;
+    /**
+     * Set the logging level for a named DMS log component.
+     *
+     * Common component names: SOURCE_UNLOAD, TARGET_LOAD, TASK_MANAGER,
+     * SOURCE_CAPTURE, TARGET_APPLY, REST_SERVER, TRANSFORMATION.
+     */
+    withLogging(component: string, level: LoggingLevel): TaskSettings;
+    /**
+     * Produce the JSON string that DMS expects for `replicationTaskSettings`.
+     */
+    toJson(): string;
+}