@jigx/core-sdk 1.0.0

package/dist/function/function.operation.js

@@ -0,0 +1,118 @@
+import { toExpression, } from '../abstract/index.js';
+export class OperationBuilder {
+    _operation;
+    constructor(operation) {
+        this._operation = operation;
+    }
+    type(operationType) {
+        this._operation.type = operationType;
+        return this;
+    }
+    when(condition) {
+        this._operation.when = condition;
+        return this;
+    }
+    table(table) {
+        this._operation.table =
+            typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table;
+        return this;
+    }
+    tables(tables) {
+        this._operation.tables = tables;
+        return this;
+    }
+    statement(sql, parameters) {
+        if (!this._operation.statements) {
+            this._operation.statements = [];
+        }
+        this._operation.statements.push({
+            statement: sql,
+            ...(parameters && { parameters }),
+        });
+        return this;
+    }
+    executeSql(tables, ...statements) {
+        this._operation.type = 'operation.execute-sql';
+        this._operation.tables = tables;
+        if (!this._operation.statements) {
+            this._operation.statements = [];
+        }
+        for (const stmt of statements) {
+            if (typeof stmt === 'string') {
+                this._operation.statements.push({ statement: stmt });
+            }
+            else {
+                this._operation.statements.push(stmt);
+            }
+        }
+        return this;
+    }
+    upsertMerge(table, records) {
+        this._operation.type = 'operation.upsert-merge';
+        this.table(table);
+        this._operation.records = records;
+        return this;
+    }
+    deleteInsert(table, records) {
+        this._operation.type = 'operation.delete-insert';
+        this.table(table);
+        this._operation.records = records;
+        return this;
+    }
+    upsertReplace(table, records) {
+        this._operation.type = 'operation.upsert-replace';
+        this.table(table);
+        this._operation.records = records;
+        return this;
+    }
+    findReplace(find, replace, tables, includeCommandQueue) {
+        this._operation.type = 'operation.find-replace';
+        this._operation.find =
+            typeof find === 'string' && find.startsWith('=') ? toExpression(find) : find;
+        this._operation.replace =
+            typeof replace === 'string' && replace.startsWith('=') ? toExpression(replace) : replace;
+        this._operation.tables = tables;
+        if (includeCommandQueue !== undefined) {
+            this._operation.includeCommandQueue =
+                typeof includeCommandQueue === 'string' && !includeCommandQueue.startsWith('=')
+                    ? `=${includeCommandQueue}`
+                    : includeCommandQueue;
+        }
+        return this;
+    }
+    primaryKey(key) {
+        this._operation.primaryKey =
+            typeof key === 'string' && key.startsWith('=') ? toExpression(key) : key;
+        return this;
+    }
+    timestamp(ts) {
+        this._operation.timestamp = typeof ts === 'string' && ts.startsWith('=') ? toExpression(ts) : ts;
+        return this;
+    }
+    conversions(conversions) {
+        this._operation.conversions = conversions;
+        return this;
+    }
+    forRowsWithValues(column, value) {
+        if (!this._operation.forRowsWithValues) {
+            this._operation.forRowsWithValues = {};
+        }
+        this._operation.forRowsWithValues[column] =
+            typeof value === 'string' && value.startsWith('=') ? toExpression(value) : value;
+        return this;
+    }
+    forRowsInRange(column, from, to) {
+        if (!this._operation.forRowsInRange) {
+            this._operation.forRowsInRange = {};
+        }
+        this._operation.forRowsInRange[column] = {
+            from: typeof from === 'string' && from.startsWith('=') ? toExpression(from) : from,
+            to: typeof to === 'string' && to.startsWith('=') ? toExpression(to) : to,
+        };
+        return this;
+    }
+    build() {
+        return this._operation;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function.operation.js","sourceRoot":"","sources":["../../src/function/function.operation.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type BooleanOrExpression,\n  type ConversionDefinition,\n  type Expression,\n  type StringOrExpression,\n  type TableName,\n  toExpression,\n} from '../abstract/index.js'\nimport type { OperationDefinition, OperationType } from './function.abstract.js'\n\n/**\n * Build operation definitions for guards and root-level operations.\n */\nexport class OperationBuilder {\n  private readonly _operation: OperationDefinition\n\n  /**\n   * Creates a new operation builder.\n   *\n   * @param operation - The operation configuration to build\n   */\n  constructor(operation: OperationDefinition) {\n    this._operation = operation\n  }\n\n  /**\n   * Set operation type.\n   *\n   * @param operationType - Operation type (e.g., 'operation.upsert-merge', 'operation.execute-sql', 'operation.delete-insert')\n   * @returns This builder for chaining\n   */\n  type(operationType: OperationType): this {\n    this._operation.type = operationType\n    return this\n  }\n\n  /**\n   * Set condition for when operation should execute.\n   *\n   * @param condition - JSONATA expression returning boolean\n   * @returns This builder for chaining\n   */\n  when(condition: Expression): this {\n    this._operation.when = condition\n    return this\n  }\n\n  /**\n   * Set target table to store operation results.\n   *\n   * @param table - Table name or expression\n   * @returns This builder for chaining\n   */\n  table(table: StringOrExpression): this {\n    this._operation.table =\n      typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table\n    return this\n  }\n\n  /**\n   * Set tables for execute-sql operations.\n   *\n   * @param tables - Array of table names\n   * @returns This builder for chaining\n   */\n  tables(tables: TableName[]): this {\n    this._operation.tables = tables\n    return this\n  }\n\n  /**\n   * Add SQL statement for execute-sql operations.\n   *\n   * @param sql - SQL statement\n   * @param parameters - Optional parameters for the statement\n   * @returns This builder for chaining\n   */\n  statement(sql: string, parameters?: Record<string, StringOrExpression>): this {\n    if (!this._operation.statements) {\n      this._operation.statements = []\n    }\n    this._operation.statements.push({\n      statement: sql,\n      ...(parameters && { parameters }),\n    })\n    return this\n  }\n\n  /**\n   * Convenience method for execute-sql operations.\n   *\n   * @param tables - Tables affected by SQL statements\n   * @param statements - SQL statements with optional parameters\n   * @returns This builder for chaining\n   */\n  executeSql(\n    tables: TableName[],\n    ...statements: Array<\n      string | { statement: string; parameters?: Record<string, StringOrExpression> }\n    >\n  ): this {\n    this._operation.type = 'operation.execute-sql'\n    this._operation.tables = tables\n\n    if (!this._operation.statements) {\n      this._operation.statements = []\n    }\n\n    for (const stmt of statements) {\n      if (typeof stmt === 'string') {\n        this._operation.statements.push({ statement: stmt })\n      } else {\n        this._operation.statements.push(stmt)\n      }\n    }\n\n    return this\n  }\n\n  /**\n   * Convenience method for upsert-merge operations.\n   *\n   * @param table - Target table\n   * @param records - JSONATA expression for records to merge\n   * @returns This builder for chaining\n   */\n  upsertMerge(table: StringOrExpression, records: Expression): this {\n    this._operation.type = 'operation.upsert-merge'\n    this.table(table)\n    this._operation.records = records\n    return this\n  }\n\n  /**\n   * Convenience method for delete-insert operations.\n   *\n   * @param table - Target table\n   * @param records - JSONATA expression for records\n   * @returns This builder for chaining\n   */\n  deleteInsert(table: StringOrExpression, records: Expression): this {\n    this._operation.type = 'operation.delete-insert'\n    this.table(table)\n    this._operation.records = records\n    return this\n  }\n\n  /**\n   * Convenience method for upsert-replace operations.\n   *\n   * @param table - Target table\n   * @param records - JSONATA expression for records\n   * @returns This builder for chaining\n   */\n  upsertReplace(table: StringOrExpression, records: Expression): this {\n    this._operation.type = 'operation.upsert-replace'\n    this.table(table)\n    this._operation.records = records\n    return this\n  }\n\n  /**\n   * Convenience method for find-replace operations.\n   *\n   * @param find - Expression to find\n   * @param replace - Expression to replace with\n   * @param tables - Tables to search\n   * @param includeCommandQueue - Include command queue in search\n   * @returns This builder for chaining\n   */\n  findReplace(\n    find: StringOrExpression,\n    replace: StringOrExpression,\n    tables: TableName[],\n    includeCommandQueue?: BooleanOrExpression,\n  ): this {\n    this._operation.type = 'operation.find-replace'\n    this._operation.find =\n      typeof find === 'string' && find.startsWith('=') ? toExpression(find) : find\n    this._operation.replace =\n      typeof replace === 'string' && replace.startsWith('=') ? toExpression(replace) : replace\n    this._operation.tables = tables\n    if (includeCommandQueue !== undefined) {\n      this._operation.includeCommandQueue =\n        typeof includeCommandQueue === 'string' && !includeCommandQueue.startsWith('=')\n          ? `=${includeCommandQueue}`\n          : includeCommandQueue\n    }\n    return this\n  }\n\n  /**\n   * Set primary key for operation.\n   *\n   * @param key - Primary key column name or expression\n   * @returns This builder for chaining\n   */\n  primaryKey(key: StringOrExpression): this {\n    this._operation.primaryKey =\n      typeof key === 'string' && key.startsWith('=') ? toExpression(key) : key\n    return this\n  }\n\n  /**\n   * Set timestamp column for operation.\n   *\n   * @param ts - Timestamp column name or expression\n   * @returns This builder for chaining\n   */\n  timestamp(ts: StringOrExpression): this {\n    this._operation.timestamp = typeof ts === 'string' && ts.startsWith('=') ? toExpression(ts) : ts\n    return this\n  }\n\n  /**\n   * Set data conversions for operation.\n   *\n   * @param conversions - Array of conversion definitions\n   * @returns This builder for chaining\n   */\n  conversions(conversions: ConversionDefinition[]): this {\n    this._operation.conversions = conversions\n    return this\n  }\n\n  /**\n   * Restrict operation to rows matching column/value pairs (delete-insert only).\n   *\n   * @param column - Column name\n   * @param value - Parameter value or expression\n   * @returns This builder for chaining\n   */\n  forRowsWithValues(column: string, value: StringOrExpression): this {\n    if (!this._operation.forRowsWithValues) {\n      this._operation.forRowsWithValues = {}\n    }\n    this._operation.forRowsWithValues[column] =\n      typeof value === 'string' && value.startsWith('=') ? toExpression(value) : value\n    return this\n  }\n\n  /**\n   * Restrict operation to rows in a range (delete-insert only).\n   *\n   * @param column - Column name\n   * @param from - Range start (value or expression)\n   * @param to - Range end (value or expression)\n   * @returns This builder for chaining\n   */\n  forRowsInRange(column: string, from: StringOrExpression, to: StringOrExpression): this {\n    if (!this._operation.forRowsInRange) {\n      this._operation.forRowsInRange = {}\n    }\n    this._operation.forRowsInRange[column] = {\n      from: typeof from === 'string' && from.startsWith('=') ? toExpression(from) : from,\n      to: typeof to === 'string' && to.startsWith('=') ? toExpression(to) : to,\n    }\n    return this\n  }\n\n  /**\n   * Build operation definition.\n   *\n   * @returns Complete operation definition object\n   */\n  build(): Record<string, unknown> {\n    return this._operation\n  }\n}\n"]}

package/dist/function/function.rest.continuation.d.ts

@@ -0,0 +1,12 @@
+import { type Expression } from '../abstract/index.js';
+import { RestParameterBuilder } from './function.rest.parameter-builder.js';
+export declare class RestContinuationBuilder {
+    private _when;
+    private _url?;
+    readonly parameters: RestParameterBuilder;
+    constructor();
+    when(condition: string | Expression): this;
+    url(url: string | URL | Expression): this;
+    build(): Record<string, unknown>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/function/function.rest.continuation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.rest.continuation.d.ts","sourceRoot":"","sources":["../../src/function/function.rest.continuation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAgB,MAAM,sBAAsB,CAAA;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAA;AAK3E,qBAAa,uBAAuB;IAClC,OAAO,CAAC,KAAK,CAAqC;IAClD,OAAO,CAAC,IAAI,CAAC,CAAQ;IAKrB,QAAQ,CAAC,UAAU,uBAA6B;IAEhD,cAAgB;IAQhB,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAGzC;IAQD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,UAAU,GAAG,IAAI,CAGxC;IAOD,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAM/B;CACF","sourcesContent":["import { type Expression, toExpression } from '../abstract/index.js'\nimport { RestParameterBuilder } from './function.rest.parameter-builder.js'\n\n/**\n * Build REST function continuation/pagination.\n */\nexport class RestContinuationBuilder {\n  private _when: Expression = toExpression('=false')\n  private _url?: string\n\n  /**\n   * Parameter builder for continuation requests.\n   */\n  readonly parameters = new RestParameterBuilder()\n\n  constructor() {}\n\n  /**\n   * Set condition to check if more pages exist.\n   *\n   * @param condition - JSONATA expression returning boolean\n   * @returns This builder for chaining\n   */\n  when(condition: string | Expression): this {\n    this._when = toExpression(condition)\n    return this\n  }\n\n  /**\n   * Set URL for next page request.\n   *\n   * @param url - Next page URL (static, expression, or URL object)\n   * @returns This builder for chaining\n   */\n  url(url: string | URL | Expression): this {\n    this._url = url instanceof URL ? url.toString() : url\n    return this\n  }\n\n  /**\n   * Build continuation definition.\n   *\n   * @returns Complete continuation definition object\n   */\n  build(): Record<string, unknown> {\n    return {\n      when: this._when,\n      ...(this._url !== undefined && { url: this._url }),\n      parameters: this.parameters.build(),\n    }\n  }\n}\n"]}

package/dist/function/function.rest.continuation.js

@@ -0,0 +1,24 @@
+import { toExpression } from '../abstract/index.js';
+import { RestParameterBuilder } from './function.rest.parameter-builder.js';
+export class RestContinuationBuilder {
+    _when = toExpression('=false');
+    _url;
+    parameters = new RestParameterBuilder();
+    constructor() { }
+    when(condition) {
+        this._when = toExpression(condition);
+        return this;
+    }
+    url(url) {
+        this._url = url instanceof URL ? url.toString() : url;
+        return this;
+    }
+    build() {
+        return {
+            when: this._when,
+            ...(this._url !== undefined && { url: this._url }),
+            parameters: this.parameters.build(),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/function/function.rest.d.ts

@@ -0,0 +1,31 @@
+import { type Expression, type FunctionId } from '../abstract/index.js';
+import { FunctionBaseBuilder } from './function.abstract.js';
+import { type HttpMethod } from './function.rest.types.js';
+import { RestContinuationBuilder } from './function.rest.continuation.js';
+import { RestParameterBuilder } from './function.rest.parameter-builder.js';
+export interface RestFunctionInput {
+    readonly functionId: FunctionId | string;
+    readonly method: HttpMethod;
+    readonly url: string | URL;
+    readonly useLocalCall?: boolean;
+}
+export declare class RestFunctionBuilder extends FunctionBaseBuilder {
+    readonly params: RestParameterBuilder;
+    private _continuation?;
+    constructor(options: RestFunctionInput);
+    get continuation(): RestContinuationBuilder;
+    format(format: string): this;
+    inputTransform(transform: string | Expression): this;
+    inputTransform(prefix: string, transform: Record<string, unknown>): this;
+    records(jsonata: string | Expression): this;
+    bearerToken(token: string): this;
+    disableTokenRefresh(value?: boolean): this;
+    useLocalCall(value?: boolean): this;
+    json(): this;
+    xml(): this;
+    form(): this;
+    base64ToUri(property: string, filename?: string): this;
+    base64ToLocalUri(property: string, filename?: string): this;
+    uriToBase64(property: string): this;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function.rest.d.ts","sourceRoot":"","sources":["../../src/function/function.rest.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,UAAU,EAIhB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AAC5D,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAA;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAA;AAK3E,MAAM,WAAW,iBAAiB;IAEhC,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAAA;IAExC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAE3B,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;IAE1B,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAA;CAChC;AAYD,qBAAa,mBAAoB,SAAQ,mBAAmB;IAC1D,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAA;IAErC,OAAO,CAAC,aAAa,CAAC,CAAyB;IAO/C,YAAY,OAAO,EAAE,iBAAiB,EASrC;IAOD,IAAI,YAAY,IAAI,uBAAuB,CAI1C;IAQD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAG3B;IAQD,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAAA;IACpD,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;IAgBxE,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAG1C;IAQD,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAG/B;IAQD,mBAAmB,CAAC,KAAK,UAAO,GAAG,IAAI,CAGtC;IAQD,YAAY,CAAC,KAAK,UAAO,GAAG,IAAI,CAG/B;IAOD,IAAI,IAAI,IAAI,CAEX;IAOD,GAAG,IAAI,IAAI,CAEV;IAOD,IAAI,IAAI,IAAI,CAEX;IASD,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAKrD;IASD,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAE1D;IAQD,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAElC;CACF","sourcesContent":["import {\n  DATA_PROVIDER,\n  type Expression,\n  type FunctionId,\n  toExpression,\n  toFunctionId,\n  toNonExpression,\n} from '../abstract/index.js'\nimport { FunctionBaseBuilder } from './function.abstract.js'\nimport { type HttpMethod } from './function.rest.types.js'\nimport { RestContinuationBuilder } from './function.rest.continuation.js'\nimport { RestParameterBuilder } from './function.rest.parameter-builder.js'\n\n/**\n * REST function builder input.\n */\nexport interface RestFunctionInput {\n  /** Unique identifier */\n  readonly functionId: FunctionId | string\n  /** HTTP method (GET, POST, PUT, PATCH, DELETE) */\n  readonly method: HttpMethod\n  /** API endpoint URL (supports {param} placeholders) */\n  readonly url: string | URL\n  /** Use local device calls instead of backend proxy */\n  readonly useLocalCall?: boolean\n}\n\n/**\n * Connect to REST APIs.\n *\n * HTTP operations with auth, transforms, pagination.\n * Supports OAuth, API Key, Basic Auth.\n * Transform with JSONata. Handle pagination.\n * Convert file formats.\n *\n * @alias DATA_PROVIDER_REST\n */\nexport class RestFunctionBuilder extends FunctionBaseBuilder {\n  readonly params: RestParameterBuilder\n\n  private _continuation?: RestContinuationBuilder\n\n  /**\n   * Create REST function builder.\n   *\n   * @param options - REST function configuration\n   */\n  constructor(options: RestFunctionInput) {\n    const { functionId, method, url, useLocalCall } = options\n    super(toFunctionId(functionId), DATA_PROVIDER.REST)\n    this._config.method = method\n    this._config.url = toNonExpression(url instanceof URL ? url.toString() : url)\n    if (useLocalCall !== undefined) this._config.useLocalCall = useLocalCall\n\n    this.params = new RestParameterBuilder()\n    this._config.parameters = this.params\n  }\n\n  /**\n   * Get continuation builder for pagination.\n   *\n   * @returns RestContinuationBuilder for fluent configuration\n   */\n  get continuation(): RestContinuationBuilder {\n    this._continuation ??= new RestContinuationBuilder()\n    this._config.continuation = this._continuation\n    return this._continuation\n  }\n\n  /**\n   * Set response format.\n   *\n   * @param format - Response format\n   * @returns Builder for chaining\n   */\n  format(format: string): this {\n    this._config.format = format\n    return this\n  }\n\n  /**\n   * Transform request data with JSONata.\n   *\n   * @param transform - JSONATA expression to transform request body\n   * @returns Builder for chaining\n   */\n  inputTransform(transform: string | Expression): this\n  inputTransform(prefix: string, transform: Record<string, unknown>): this\n  inputTransform(txOrPx: string | Expression, transform?: Record<string, unknown>): this {\n    let tx: string = txOrPx.trimStart()\n    // if (tx.startsWith('=')) tx = tx.slice(1).trimStart()\n    if (transform) tx += JSON.stringify(transform)\n\n    this._config.inputTransform = tx\n    return this\n  }\n\n  /**\n   * Extract specific records from response.\n   *\n   * @param jsonata - Expression to extract records (starts with =)\n   * @returns This builder for chaining\n   */\n  records(jsonata: string | Expression): this {\n    this._config.records = toExpression(jsonata)\n    return this\n  }\n\n  /**\n   * Set Authorization header with Bearer token.\n   *\n   * @param token - Bearer token value or expression\n   * @returns This builder for chaining\n   */\n  bearerToken(token: string): this {\n    this.params.bearer(token)\n    return this\n  }\n\n  /**\n   * Disable automatic 401 token refresh.\n   *\n   * @param value - Whether to disable (default: true)\n   * @returns This builder for chaining\n   */\n  disableTokenRefresh(value = true): this {\n    this._config.disableTokenRefresh = value\n    return this\n  }\n\n  /**\n   * Use local device calls instead of backend proxy.\n   *\n   * @param value - Whether to use local calls (default: true)\n   * @returns This builder for chaining\n   */\n  useLocalCall(value = true): this {\n    this._config.useLocalCall = value\n    return this\n  }\n\n  /**\n   * Shortcut for JSON format (most common).\n   *\n   * @returns This builder for chaining\n   */\n  json(): this {\n    return this.format('json')\n  }\n\n  /**\n   * Shortcut for XML format.\n   *\n   * @returns This builder for chaining\n   */\n  xml(): this {\n    return this.format('xml')\n  }\n\n  /**\n   * Shortcut for form-encoded format.\n   *\n   * @returns This builder for chaining\n   */\n  form(): this {\n    return this.format('form')\n  }\n\n  /**\n   * Convert base64-encoded data to URI format.\n   *\n   * @param property - Property path containing base64 data\n   * @param filename - Optional filename for local storage (uses local-uri if provided, data-uri otherwise)\n   * @returns This builder for chaining\n   */\n  base64ToUri(property: string, filename?: string): this {\n    if (filename) {\n      return this.conversion(property, 'base64', 'local-uri', filename)\n    }\n    return this.conversion(property, 'base64', 'data-uri')\n  }\n\n  /**\n   * Convert base64-encoded data to local-uri format.\n   *\n   * @param property - Property path containing base64 data\n   * @param filename - Optional filename for local storage\n   * @returns This builder for chaining\n   */\n  base64ToLocalUri(property: string, filename?: string): this {\n    return this.conversion(property, 'base64', 'local-uri', filename)\n  }\n\n  /**\n   * Convert URI (local file) to base64 encoding.\n   *\n   * @param property - Property path containing URI\n   * @returns This builder for chaining\n   */\n  uriToBase64(property: string): this {\n    return this.conversion(property, 'local-uri', 'base64')\n  }\n}\n"]}

package/dist/function/function.rest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.rest.d.ts","sourceRoot":"","sources":["../../src/function/function.rest.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,UAAU,EAIhB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AAC5D,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAA;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAA;AAK3E,MAAM,WAAW,iBAAiB;IAEhC,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAAA;IAExC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAE3B,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;IAE1B,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAA;CAChC;AAYD,qBAAa,mBAAoB,SAAQ,mBAAmB;IAC1D,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAA;IAErC,OAAO,CAAC,aAAa,CAAC,CAAyB;IAO/C,YAAY,OAAO,EAAE,iBAAiB,EASrC;IAOD,IAAI,YAAY,IAAI,uBAAuB,CAI1C;IAQD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAG3B;IAQD,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAAA;IACpD,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;IAgBxE,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAG1C;IAQD,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAG/B;IAQD,mBAAmB,CAAC,KAAK,UAAO,GAAG,IAAI,CAGtC;IAQD,YAAY,CAAC,KAAK,UAAO,GAAG,IAAI,CAG/B;IAOD,IAAI,IAAI,IAAI,CAEX;IAOD,GAAG,IAAI,IAAI,CAEV;IAOD,IAAI,IAAI,IAAI,CAEX;IASD,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAKrD;IASD,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAE1D;IAQD,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAElC;CACF","sourcesContent":["import {\n  DATA_PROVIDER,\n  type Expression,\n  type FunctionId,\n  toExpression,\n  toFunctionId,\n  toNonExpression,\n} from '../abstract/index.js'\nimport { FunctionBaseBuilder } from './function.abstract.js'\nimport { type HttpMethod } from './function.rest.types.js'\nimport { RestContinuationBuilder } from './function.rest.continuation.js'\nimport { RestParameterBuilder } from './function.rest.parameter-builder.js'\n\n/**\n * REST function builder input.\n */\nexport interface RestFunctionInput {\n  /** Unique identifier */\n  readonly functionId: FunctionId | string\n  /** HTTP method (GET, POST, PUT, PATCH, DELETE) */\n  readonly method: HttpMethod\n  /** API endpoint URL (supports {param} placeholders) */\n  readonly url: string | URL\n  /** Use local device calls instead of backend proxy */\n  readonly useLocalCall?: boolean\n}\n\n/**\n * Connect to REST APIs.\n *\n * HTTP operations with auth, transforms, pagination.\n * Supports OAuth, API Key, Basic Auth.\n * Transform with JSONata. Handle pagination.\n * Convert file formats.\n *\n * @alias DATA_PROVIDER_REST\n */\nexport class RestFunctionBuilder extends FunctionBaseBuilder {\n  readonly params: RestParameterBuilder\n\n  private _continuation?: RestContinuationBuilder\n\n  /**\n   * Create REST function builder.\n   *\n   * @param options - REST function configuration\n   */\n  constructor(options: RestFunctionInput) {\n    const { functionId, method, url, useLocalCall } = options\n    super(toFunctionId(functionId), DATA_PROVIDER.REST)\n    this._config.method = method\n    this._config.url = toNonExpression(url instanceof URL ? url.toString() : url)\n    if (useLocalCall !== undefined) this._config.useLocalCall = useLocalCall\n\n    this.params = new RestParameterBuilder()\n    this._config.parameters = this.params\n  }\n\n  /**\n   * Get continuation builder for pagination.\n   *\n   * @returns RestContinuationBuilder for fluent configuration\n   */\n  get continuation(): RestContinuationBuilder {\n    this._continuation ??= new RestContinuationBuilder()\n    this._config.continuation = this._continuation\n    return this._continuation\n  }\n\n  /**\n   * Set response format.\n   *\n   * @param format - Response format\n   * @returns Builder for chaining\n   */\n  format(format: string): this {\n    this._config.format = format\n    return this\n  }\n\n  /**\n   * Transform request data with JSONata.\n   *\n   * @param transform - JSONATA expression to transform request body\n   * @returns Builder for chaining\n   */\n  inputTransform(transform: string | Expression): this\n  inputTransform(prefix: string, transform: Record<string, unknown>): this\n  inputTransform(txOrPx: string | Expression, transform?: Record<string, unknown>): this {\n    let tx: string = txOrPx.trimStart()\n    // if (tx.startsWith('=')) tx = tx.slice(1).trimStart()\n    if (transform) tx += JSON.stringify(transform)\n\n    this._config.inputTransform = tx\n    return this\n  }\n\n  /**\n   * Extract specific records from response.\n   *\n   * @param jsonata - Expression to extract records (starts with =)\n   * @returns This builder for chaining\n   */\n  records(jsonata: string | Expression): this {\n    this._config.records = toExpression(jsonata)\n    return this\n  }\n\n  /**\n   * Set Authorization header with Bearer token.\n   *\n   * @param token - Bearer token value or expression\n   * @returns This builder for chaining\n   */\n  bearerToken(token: string): this {\n    this.params.bearer(token)\n    return this\n  }\n\n  /**\n   * Disable automatic 401 token refresh.\n   *\n   * @param value - Whether to disable (default: true)\n   * @returns This builder for chaining\n   */\n  disableTokenRefresh(value = true): this {\n    this._config.disableTokenRefresh = value\n    return this\n  }\n\n  /**\n   * Use local device calls instead of backend proxy.\n   *\n   * @param value - Whether to use local calls (default: true)\n   * @returns This builder for chaining\n   */\n  useLocalCall(value = true): this {\n    this._config.useLocalCall = value\n    return this\n  }\n\n  /**\n   * Shortcut for JSON format (most common).\n   *\n   * @returns This builder for chaining\n   */\n  json(): this {\n    return this.format('json')\n  }\n\n  /**\n   * Shortcut for XML format.\n   *\n   * @returns This builder for chaining\n   */\n  xml(): this {\n    return this.format('xml')\n  }\n\n  /**\n   * Shortcut for form-encoded format.\n   *\n   * @returns This builder for chaining\n   */\n  form(): this {\n    return this.format('form')\n  }\n\n  /**\n   * Convert base64-encoded data to URI format.\n   *\n   * @param property - Property path containing base64 data\n   * @param filename - Optional filename for local storage (uses local-uri if provided, data-uri otherwise)\n   * @returns This builder for chaining\n   */\n  base64ToUri(property: string, filename?: string): this {\n    if (filename) {\n      return this.conversion(property, 'base64', 'local-uri', filename)\n    }\n    return this.conversion(property, 'base64', 'data-uri')\n  }\n\n  /**\n   * Convert base64-encoded data to local-uri format.\n   *\n   * @param property - Property path containing base64 data\n   * @param filename - Optional filename for local storage\n   * @returns This builder for chaining\n   */\n  base64ToLocalUri(property: string, filename?: string): this {\n    return this.conversion(property, 'base64', 'local-uri', filename)\n  }\n\n  /**\n   * Convert URI (local file) to base64 encoding.\n   *\n   * @param property - Property path containing URI\n   * @returns This builder for chaining\n   */\n  uriToBase64(property: string): this {\n    return this.conversion(property, 'local-uri', 'base64')\n  }\n}\n"]}

package/dist/function/function.rest.error-builder.d.ts

@@ -0,0 +1,38 @@
+import { type Expression, type TextValue, TextValueBuilder } from '../abstract/index.js';
+import { type IconName } from '../icon/index.js';
+import type { FunctionErrorHandlerAlert, FunctionErrorHandlerOperation, FunctionErrorHandlerRetry, OperationType } from './function.abstract.js';
+export declare class ErrorOperationBuilder {
+    private readonly _operation;
+    constructor(operation: FunctionErrorHandlerOperation);
+    when(condition: string | Expression): this;
+    table(table: string | Expression): this;
+    type(operationType: OperationType): this;
+    tables(tables: string[]): this;
+    statement(sql: string, parameters?: Record<string, string | Expression>): this;
+    executeSql(tables: string[], ...statements: Array<string | {
+        statement: string;
+        parameters?: Record<string, string | Expression>;
+    }>): this;
+    upsertMerge(table: string | Expression): this;
+    upsertReplace(table: string | Expression): this;
+    deleteInsert(table: string | Expression): this;
+    build(): Record<string, unknown>;
+}
+export declare class FunctionErrorBuilder {
+    private readonly _error;
+    constructor(when: boolean | string | Expression);
+    title(title: string | Expression | TextValue | TextValueBuilder): this;
+    description(description: string | TextValue | TextValueBuilder): this;
+    details(details: string | Expression | TextValue | TextValueBuilder): this;
+    icon(icon: IconName | Expression): this;
+    notification(show: boolean | Expression, title?: string | Expression | TextValue | TextValueBuilder, description?: string | Expression | TextValue | TextValueBuilder): this;
+    transform(jsonata: string | Expression): this;
+    transform(prefix: string, transform: Record<string, unknown>): this;
+    table(table: string | Expression): this;
+    operation(records?: string | Expression): ErrorOperationBuilder;
+    retry(config: FunctionErrorHandlerRetry): this;
+    when(condition: boolean | string | Expression): this;
+    alert(options: FunctionErrorHandlerAlert): this;
+    build(): Record<string, unknown>;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function.rest.error-builder.d.ts","sourceRoot":"","sources":["../../src/function/function.rest.error-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type Expression,\n  type TextValue,\n  TextValueBuilder,\n  toExpression,\n} from '../abstract/index.js'\nimport { type IconName, toIconNameOrExpression } from '../icon/index.js'\nimport type {\n  FunctionErrorHandlerAlert,\n  FunctionErrorHandlerDefinition,\n  FunctionErrorHandlerOperation,\n  FunctionErrorHandlerRetry,\n  OperationType,\n} from './function.abstract.js'\n\n/**\n * Build error handler operations.\n */\nexport class ErrorOperationBuilder {\n  private readonly _operation: FunctionErrorHandlerOperation\n\n  /**\n   * Creates a new error operation builder.\n   *\n   * @param operation - The operation configuration to build\n   */\n  constructor(operation: FunctionErrorHandlerOperation) {\n    this._operation = operation\n  }\n\n  /**\n   * Set condition for when operation should execute.\n   *\n   * @param condition - JSONATA expression returning boolean\n   * @returns This builder for chaining\n   */\n  when(condition: string | Expression): this {\n    this._operation.when = toExpression(condition)\n    return this\n  }\n\n  /**\n   * Set target table to store operation results.\n   *\n   * @param table - Table name or expression\n   * @returns This builder for chaining\n   */\n  table(table: string | Expression): this {\n    this._operation.table =\n      typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table\n    return this\n  }\n\n  /**\n   * Set operation type.\n   *\n   * @param operationType - Operation type (e.g., 'operation.upsert-merge', 'operation.execute-sql')\n   * @returns This builder for chaining\n   */\n  type(operationType: OperationType): this {\n    this._operation.type = operationType\n    return this\n  }\n\n  /**\n   * Set tables for execute-sql operations.\n   *\n   * @param tables - Array of table names\n   * @returns This builder for chaining\n   */\n  tables(tables: string[]): this {\n    this._operation.tables = tables\n    return this\n  }\n\n  /**\n   * Add SQL statement for execute-sql operations.\n   *\n   * @param sql - SQL statement\n   * @param parameters - Optional parameters for the statement\n   * @returns This builder for chaining\n   */\n  statement(sql: string, parameters?: Record<string, string | Expression>): this {\n    if (!this._operation.statements) {\n      this._operation.statements = []\n    }\n    this._operation.statements.push({\n      statement: sql,\n      ...(parameters && { parameters }),\n    })\n    return this\n  }\n\n  /**\n   * Convenience method for execute-sql operations.\n   *\n   * @param tables - Tables affected by SQL statements\n   * @param statements - SQL statements with optional parameters\n   * @returns This builder for chaining\n   */\n  executeSql(\n    tables: string[],\n    ...statements: Array<\n      string | { statement: string; parameters?: Record<string, string | Expression> }\n    >\n  ): this {\n    this._operation.type = 'operation.execute-sql'\n    this._operation.tables = tables\n\n    if (!this._operation.statements) {\n      this._operation.statements = []\n    }\n\n    for (const stmt of statements) {\n      if (typeof stmt === 'string') {\n        this._operation.statements.push({ statement: stmt })\n      } else {\n        this._operation.statements.push(stmt)\n      }\n    }\n\n    return this\n  }\n\n  /**\n   * Convenience method for upsert-merge operations.\n   *\n   * @param table - Target table name or expression\n   * @returns This builder for chaining\n   */\n  upsertMerge(table: string | Expression): this {\n    this._operation.type = 'operation.upsert-merge'\n    this._operation.table =\n      typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table\n    return this\n  }\n\n  /**\n   * Convenience method for upsert-replace operations.\n   *\n   * @param table - Target table name or expression\n   * @returns This builder for chaining\n   */\n  upsertReplace(table: string | Expression): this {\n    this._operation.type = 'operation.upsert-replace'\n    this._operation.table =\n      typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table\n    return this\n  }\n\n  /**\n   * Convenience method for delete-insert operations.\n   *\n   * @param table - Target table name or expression\n   * @returns This builder for chaining\n   */\n  deleteInsert(table: string | Expression): this {\n    this._operation.type = 'operation.delete-insert'\n    this._operation.table =\n      typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table\n    return this\n  }\n\n  /**\n   * Build error operation definition.\n   *\n   * @returns Complete error operation definition object\n   */\n  build(): Record<string, unknown> {\n    return this._operation\n  }\n}\n\n/**\n * Build function error handlers.\n */\nexport class FunctionErrorBuilder {\n  private readonly _error: FunctionErrorHandlerDefinition\n\n  /**\n   * Creates a new error handler builder.\n   *\n   * @param when - Required condition (boolean or expression). Boolean true/false converts to '=true'/'=false'\n   */\n  constructor(when: boolean | string | Expression) {\n    // Convert boolean to expression\n    const whenExpr = typeof when === 'boolean' ? `=${String(when)}` : when\n    this._error = {\n      when: toExpression(whenExpr),\n    }\n  }\n\n  /**\n   * Set error title shown in notifications.\n   *\n   * @param title - Static text, expression (=...), or TextValue\n   * @default title is the same as description if not set.\n   * @returns This builder for chaining\n   */\n  title(title: string | Expression | TextValue | TextValueBuilder): this {\n    if (typeof title === 'string' && title.startsWith('=')) {\n      this._error.title = toExpression(title)\n    } else {\n      this._error.title = TextValueBuilder.from(title)\n    }\n    this._error.description ||= this._error.title\n    return this\n  }\n\n  /**\n   * Set error description for user-facing notifications.\n   *\n   * @param description - Descriptive text or TextValue\n   * @returns This builder for chaining\n   */\n  description(description: string | TextValue | TextValueBuilder): this {\n    this._error.description = TextValueBuilder.from(description)\n    return this\n  }\n\n  /**\n   * Set additional error details.\n   *\n   * @param details - Static text, expression, or TextValue\n   * @returns This builder for chaining\n   */\n  details(details: string | Expression | TextValue | TextValueBuilder): this {\n    if (typeof details === 'string' && details.startsWith('=')) {\n      this._error.details = toExpression(details)\n    } else {\n      this._error.details = TextValueBuilder.from(details)\n    }\n    return this\n  }\n\n  /**\n   * Set icon for error notifications.\n   *\n   * @param icon - Icon name, expression, or IconName type\n   * @returns This builder for chaining\n   */\n  icon(icon: IconName | Expression): this {\n    this._error.icon = toIconNameOrExpression(icon)\n    return this\n  }\n\n  /**\n   * Control whether to show error notification to user.\n   *\n   * @param show - Boolean or expression\n   * @param title\n   * @param description\n   * @default true\n   * @returns This builder for chaining\n   */\n  notification(\n    show: boolean | Expression,\n    title?: string | Expression | TextValue | TextValueBuilder,\n    description?: string | Expression | TextValue | TextValueBuilder,\n  ): this {\n    if (title) this.title(title)\n    if (description) this.description(description)\n    this._error.notification = typeof show === 'boolean' ? show : toExpression(show as string)\n    return this\n  }\n\n  /**\n   * Transform error data before storage/display.\n   *\n   * @param jsonata - JSONATA expression string\n   * @returns This builder for chaining\n   */\n  transform(jsonata: string | Expression): this\n  transform(prefix: string, transform: Record<string, unknown>): this\n  transform(txOrPx: string | Expression, transform?: Record<string, unknown>): this {\n    let tx: string = txOrPx.trimStart()\n    // if (tx.startsWith('=')) tx = tx.slice(1).trimStart()\n    if (transform) tx += JSON.stringify(transform)\n\n    this._error.transform = tx // toExpression(tx)\n    return this\n  }\n\n  /**\n   * Store error data in specified table.\n   *\n   * @param table - Table name or expression\n   * @returns This builder for chaining\n   */\n  table(table: string | Expression): this {\n    this._error.table =\n      typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table\n    return this\n  }\n\n  /**\n   * Add operation to perform when error occurs.\n   *\n   * @param records - JSONATA expression for operation data (optional for execute-sql operations)\n   * @returns ErrorOperationBuilder for further configuration\n   */\n  operation(records?: string | Expression): ErrorOperationBuilder {\n    if (!this._error.operations) {\n      this._error.operations = []\n    }\n\n    const operation: FunctionErrorHandlerOperation = {\n      ...(records !== undefined && { records: toExpression(records) }),\n    }\n    this._error.operations.push(operation)\n\n    return new ErrorOperationBuilder(operation)\n  }\n\n  /**\n   * Configure automatic retry behavior for errors.\n   *\n   * @param config - Retry configuration with when, delay, maxRetries\n   * @returns This builder for chaining\n   */\n  retry(config: FunctionErrorHandlerRetry): this {\n    this._error.retry = {\n      ...(config.when && { when: toExpression(config.when) }),\n      ...(config.delay !== undefined && {\n        delay: typeof config.delay === 'number' ? config.delay : toExpression(config.delay),\n      }),\n      ...(config.maxRetries !== undefined && { maxRetries: config.maxRetries }),\n    }\n    return this\n  }\n\n  /**\n   * Override when condition.\n   *\n   * @param condition - Boolean or JSONATA expression\n   * @returns This builder for chaining\n   */\n  when(condition: boolean | string | Expression): this {\n    const whenExpr = typeof condition === 'boolean' ? `=${String(condition)}` : condition\n    this._error.when = toExpression(whenExpr)\n    return this\n  }\n\n  /**\n   * Configure alert notification for this error handler.\n   *\n   * @param options - Alert configuration\n   * @returns This builder for chaining\n   */\n  alert(options: FunctionErrorHandlerAlert): this {\n    this._error.alert = options\n    return this\n  }\n\n  /**\n   * Build error handler definition.\n   *\n   * @returns Complete error handler definition object\n   */\n  build(): Record<string, unknown> {\n    return this._error\n  }\n}\n"]}

package/dist/function/function.rest.error-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.rest.error-builder.d.ts","sourceRoot":"","sources":["../../src/function/function.rest.error-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type Expression,\n  type TextValue,\n  TextValueBuilder,\n  toExpression,\n} from '../abstract/index.js'\nimport { type IconName, toIconNameOrExpression } from '../icon/index.js'\nimport type {\n  FunctionErrorHandlerAlert,\n  FunctionErrorHandlerDefinition,\n  FunctionErrorHandlerOperation,\n  FunctionErrorHandlerRetry,\n  OperationType,\n} from './function.abstract.js'\n\n/**\n * Build error handler operations.\n */\nexport class ErrorOperationBuilder {\n  private readonly _operation: FunctionErrorHandlerOperation\n\n  /**\n   * Creates a new error operation builder.\n   *\n   * @param operation - The operation configuration to build\n   */\n  constructor(operation: FunctionErrorHandlerOperation) {\n    this._operation = operation\n  }\n\n  /**\n   * Set condition for when operation should execute.\n   *\n   * @param condition - JSONATA expression returning boolean\n   * @returns This builder for chaining\n   */\n  when(condition: string | Expression): this {\n    this._operation.when = toExpression(condition)\n    return this\n  }\n\n  /**\n   * Set target table to store operation results.\n   *\n   * @param table - Table name or expression\n   * @returns This builder for chaining\n   */\n  table(table: string | Expression): this {\n    this._operation.table =\n      typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table\n    return this\n  }\n\n  /**\n   * Set operation type.\n   *\n   * @param operationType - Operation type (e.g., 'operation.upsert-merge', 'operation.execute-sql')\n   * @returns This builder for chaining\n   */\n  type(operationType: OperationType): this {\n    this._operation.type = operationType\n    return this\n  }\n\n  /**\n   * Set tables for execute-sql operations.\n   *\n   * @param tables - Array of table names\n   * @returns This builder for chaining\n   */\n  tables(tables: string[]): this {\n    this._operation.tables = tables\n    return this\n  }\n\n  /**\n   * Add SQL statement for execute-sql operations.\n   *\n   * @param sql - SQL statement\n   * @param parameters - Optional parameters for the statement\n   * @returns This builder for chaining\n   */\n  statement(sql: string, parameters?: Record<string, string | Expression>): this {\n    if (!this._operation.statements) {\n      this._operation.statements = []\n    }\n    this._operation.statements.push({\n      statement: sql,\n      ...(parameters && { parameters }),\n    })\n    return this\n  }\n\n  /**\n   * Convenience method for execute-sql operations.\n   *\n   * @param tables - Tables affected by SQL statements\n   * @param statements - SQL statements with optional parameters\n   * @returns This builder for chaining\n   */\n  executeSql(\n    tables: string[],\n    ...statements: Array<\n      string | { statement: string; parameters?: Record<string, string | Expression> }\n    >\n  ): this {\n    this._operation.type = 'operation.execute-sql'\n    this._operation.tables = tables\n\n    if (!this._operation.statements) {\n      this._operation.statements = []\n    }\n\n    for (const stmt of statements) {\n      if (typeof stmt === 'string') {\n        this._operation.statements.push({ statement: stmt })\n      } else {\n        this._operation.statements.push(stmt)\n      }\n    }\n\n    return this\n  }\n\n  /**\n   * Convenience method for upsert-merge operations.\n   *\n   * @param table - Target table name or expression\n   * @returns This builder for chaining\n   */\n  upsertMerge(table: string | Expression): this {\n    this._operation.type = 'operation.upsert-merge'\n    this._operation.table =\n      typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table\n    return this\n  }\n\n  /**\n   * Convenience method for upsert-replace operations.\n   *\n   * @param table - Target table name or expression\n   * @returns This builder for chaining\n   */\n  upsertReplace(table: string | Expression): this {\n    this._operation.type = 'operation.upsert-replace'\n    this._operation.table =\n      typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table\n    return this\n  }\n\n  /**\n   * Convenience method for delete-insert operations.\n   *\n   * @param table - Target table name or expression\n   * @returns This builder for chaining\n   */\n  deleteInsert(table: string | Expression): this {\n    this._operation.type = 'operation.delete-insert'\n    this._operation.table =\n      typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table\n    return this\n  }\n\n  /**\n   * Build error operation definition.\n   *\n   * @returns Complete error operation definition object\n   */\n  build(): Record<string, unknown> {\n    return this._operation\n  }\n}\n\n/**\n * Build function error handlers.\n */\nexport class FunctionErrorBuilder {\n  private readonly _error: FunctionErrorHandlerDefinition\n\n  /**\n   * Creates a new error handler builder.\n   *\n   * @param when - Required condition (boolean or expression). Boolean true/false converts to '=true'/'=false'\n   */\n  constructor(when: boolean | string | Expression) {\n    // Convert boolean to expression\n    const whenExpr = typeof when === 'boolean' ? `=${String(when)}` : when\n    this._error = {\n      when: toExpression(whenExpr),\n    }\n  }\n\n  /**\n   * Set error title shown in notifications.\n   *\n   * @param title - Static text, expression (=...), or TextValue\n   * @default title is the same as description if not set.\n   * @returns This builder for chaining\n   */\n  title(title: string | Expression | TextValue | TextValueBuilder): this {\n    if (typeof title === 'string' && title.startsWith('=')) {\n      this._error.title = toExpression(title)\n    } else {\n      this._error.title = TextValueBuilder.from(title)\n    }\n    this._error.description ||= this._error.title\n    return this\n  }\n\n  /**\n   * Set error description for user-facing notifications.\n   *\n   * @param description - Descriptive text or TextValue\n   * @returns This builder for chaining\n   */\n  description(description: string | TextValue | TextValueBuilder): this {\n    this._error.description = TextValueBuilder.from(description)\n    return this\n  }\n\n  /**\n   * Set additional error details.\n   *\n   * @param details - Static text, expression, or TextValue\n   * @returns This builder for chaining\n   */\n  details(details: string | Expression | TextValue | TextValueBuilder): this {\n    if (typeof details === 'string' && details.startsWith('=')) {\n      this._error.details = toExpression(details)\n    } else {\n      this._error.details = TextValueBuilder.from(details)\n    }\n    return this\n  }\n\n  /**\n   * Set icon for error notifications.\n   *\n   * @param icon - Icon name, expression, or IconName type\n   * @returns This builder for chaining\n   */\n  icon(icon: IconName | Expression): this {\n    this._error.icon = toIconNameOrExpression(icon)\n    return this\n  }\n\n  /**\n   * Control whether to show error notification to user.\n   *\n   * @param show - Boolean or expression\n   * @param title\n   * @param description\n   * @default true\n   * @returns This builder for chaining\n   */\n  notification(\n    show: boolean | Expression,\n    title?: string | Expression | TextValue | TextValueBuilder,\n    description?: string | Expression | TextValue | TextValueBuilder,\n  ): this {\n    if (title) this.title(title)\n    if (description) this.description(description)\n    this._error.notification = typeof show === 'boolean' ? show : toExpression(show as string)\n    return this\n  }\n\n  /**\n   * Transform error data before storage/display.\n   *\n   * @param jsonata - JSONATA expression string\n   * @returns This builder for chaining\n   */\n  transform(jsonata: string | Expression): this\n  transform(prefix: string, transform: Record<string, unknown>): this\n  transform(txOrPx: string | Expression, transform?: Record<string, unknown>): this {\n    let tx: string = txOrPx.trimStart()\n    // if (tx.startsWith('=')) tx = tx.slice(1).trimStart()\n    if (transform) tx += JSON.stringify(transform)\n\n    this._error.transform = tx // toExpression(tx)\n    return this\n  }\n\n  /**\n   * Store error data in specified table.\n   *\n   * @param table - Table name or expression\n   * @returns This builder for chaining\n   */\n  table(table: string | Expression): this {\n    this._error.table =\n      typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table\n    return this\n  }\n\n  /**\n   * Add operation to perform when error occurs.\n   *\n   * @param records - JSONATA expression for operation data (optional for execute-sql operations)\n   * @returns ErrorOperationBuilder for further configuration\n   */\n  operation(records?: string | Expression): ErrorOperationBuilder {\n    if (!this._error.operations) {\n      this._error.operations = []\n    }\n\n    const operation: FunctionErrorHandlerOperation = {\n      ...(records !== undefined && { records: toExpression(records) }),\n    }\n    this._error.operations.push(operation)\n\n    return new ErrorOperationBuilder(operation)\n  }\n\n  /**\n   * Configure automatic retry behavior for errors.\n   *\n   * @param config - Retry configuration with when, delay, maxRetries\n   * @returns This builder for chaining\n   */\n  retry(config: FunctionErrorHandlerRetry): this {\n    this._error.retry = {\n      ...(config.when && { when: toExpression(config.when) }),\n      ...(config.delay !== undefined && {\n        delay: typeof config.delay === 'number' ? config.delay : toExpression(config.delay),\n      }),\n      ...(config.maxRetries !== undefined && { maxRetries: config.maxRetries }),\n    }\n    return this\n  }\n\n  /**\n   * Override when condition.\n   *\n   * @param condition - Boolean or JSONATA expression\n   * @returns This builder for chaining\n   */\n  when(condition: boolean | string | Expression): this {\n    const whenExpr = typeof condition === 'boolean' ? `=${String(condition)}` : condition\n    this._error.when = toExpression(whenExpr)\n    return this\n  }\n\n  /**\n   * Configure alert notification for this error handler.\n   *\n   * @param options - Alert configuration\n   * @returns This builder for chaining\n   */\n  alert(options: FunctionErrorHandlerAlert): this {\n    this._error.alert = options\n    return this\n  }\n\n  /**\n   * Build error handler definition.\n   *\n   * @returns Complete error handler definition object\n   */\n  build(): Record<string, unknown> {\n    return this._error\n  }\n}\n"]}

package/dist/function/function.rest.error-builder.js

@@ -0,0 +1,161 @@
+import { TextValueBuilder, toExpression, } from '../abstract/index.js';
+import { toIconNameOrExpression } from '../icon/index.js';
+export class ErrorOperationBuilder {
+    _operation;
+    constructor(operation) {
+        this._operation = operation;
+    }
+    when(condition) {
+        this._operation.when = toExpression(condition);
+        return this;
+    }
+    table(table) {
+        this._operation.table =
+            typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table;
+        return this;
+    }
+    type(operationType) {
+        this._operation.type = operationType;
+        return this;
+    }
+    tables(tables) {
+        this._operation.tables = tables;
+        return this;
+    }
+    statement(sql, parameters) {
+        if (!this._operation.statements) {
+            this._operation.statements = [];
+        }
+        this._operation.statements.push({
+            statement: sql,
+            ...(parameters && { parameters }),
+        });
+        return this;
+    }
+    executeSql(tables, ...statements) {
+        this._operation.type = 'operation.execute-sql';
+        this._operation.tables = tables;
+        if (!this._operation.statements) {
+            this._operation.statements = [];
+        }
+        for (const stmt of statements) {
+            if (typeof stmt === 'string') {
+                this._operation.statements.push({ statement: stmt });
+            }
+            else {
+                this._operation.statements.push(stmt);
+            }
+        }
+        return this;
+    }
+    upsertMerge(table) {
+        this._operation.type = 'operation.upsert-merge';
+        this._operation.table =
+            typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table;
+        return this;
+    }
+    upsertReplace(table) {
+        this._operation.type = 'operation.upsert-replace';
+        this._operation.table =
+            typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table;
+        return this;
+    }
+    deleteInsert(table) {
+        this._operation.type = 'operation.delete-insert';
+        this._operation.table =
+            typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table;
+        return this;
+    }
+    build() {
+        return this._operation;
+    }
+}
+export class FunctionErrorBuilder {
+    _error;
+    constructor(when) {
+        const whenExpr = typeof when === 'boolean' ? `=${String(when)}` : when;
+        this._error = {
+            when: toExpression(whenExpr),
+        };
+    }
+    title(title) {
+        if (typeof title === 'string' && title.startsWith('=')) {
+            this._error.title = toExpression(title);
+        }
+        else {
+            this._error.title = TextValueBuilder.from(title);
+        }
+        this._error.description ||= this._error.title;
+        return this;
+    }
+    description(description) {
+        this._error.description = TextValueBuilder.from(description);
+        return this;
+    }
+    details(details) {
+        if (typeof details === 'string' && details.startsWith('=')) {
+            this._error.details = toExpression(details);
+        }
+        else {
+            this._error.details = TextValueBuilder.from(details);
+        }
+        return this;
+    }
+    icon(icon) {
+        this._error.icon = toIconNameOrExpression(icon);
+        return this;
+    }
+    notification(show, title, description) {
+        if (title)
+            this.title(title);
+        if (description)
+            this.description(description);
+        this._error.notification = typeof show === 'boolean' ? show : toExpression(show);
+        return this;
+    }
+    transform(txOrPx, transform) {
+        let tx = txOrPx.trimStart();
+        if (transform)
+            tx += JSON.stringify(transform);
+        this._error.transform = tx;
+        return this;
+    }
+    table(table) {
+        this._error.table =
+            typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table;
+        return this;
+    }
+    operation(records) {
+        if (!this._error.operations) {
+            this._error.operations = [];
+        }
+        const operation = {
+            ...(records !== undefined && { records: toExpression(records) }),
+        };
+        this._error.operations.push(operation);
+        return new ErrorOperationBuilder(operation);
+    }
+    retry(config) {
+        this._error.retry = {
+            ...(config.when && { when: toExpression(config.when) }),
+            ...(config.delay !== undefined && {
+                delay: typeof config.delay === 'number' ? config.delay : toExpression(config.delay),
+            }),
+            ...(config.maxRetries !== undefined && { maxRetries: config.maxRetries }),
+        };
+        return this;
+    }
+    when(condition) {
+        const whenExpr = typeof condition === 'boolean' ? `=${String(condition)}` : condition;
+        this._error.when = toExpression(whenExpr);
+        return this;
+    }
+    alert(options) {
+        this._error.alert = options;
+        return this;
+    }
+    build() {
+        return this._error;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function.rest.error-builder.js","sourceRoot":"","sources":["../../src/function/function.rest.error-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type Expression,\n  type TextValue,\n  TextValueBuilder,\n  toExpression,\n} from '../abstract/index.js'\nimport { type IconName, toIconNameOrExpression } from '../icon/index.js'\nimport type {\n  FunctionErrorHandlerAlert,\n  FunctionErrorHandlerDefinition,\n  FunctionErrorHandlerOperation,\n  FunctionErrorHandlerRetry,\n  OperationType,\n} from './function.abstract.js'\n\n/**\n * Build error handler operations.\n */\nexport class ErrorOperationBuilder {\n  private readonly _operation: FunctionErrorHandlerOperation\n\n  /**\n   * Creates a new error operation builder.\n   *\n   * @param operation - The operation configuration to build\n   */\n  constructor(operation: FunctionErrorHandlerOperation) {\n    this._operation = operation\n  }\n\n  /**\n   * Set condition for when operation should execute.\n   *\n   * @param condition - JSONATA expression returning boolean\n   * @returns This builder for chaining\n   */\n  when(condition: string | Expression): this {\n    this._operation.when = toExpression(condition)\n    return this\n  }\n\n  /**\n   * Set target table to store operation results.\n   *\n   * @param table - Table name or expression\n   * @returns This builder for chaining\n   */\n  table(table: string | Expression): this {\n    this._operation.table =\n      typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table\n    return this\n  }\n\n  /**\n   * Set operation type.\n   *\n   * @param operationType - Operation type (e.g., 'operation.upsert-merge', 'operation.execute-sql')\n   * @returns This builder for chaining\n   */\n  type(operationType: OperationType): this {\n    this._operation.type = operationType\n    return this\n  }\n\n  /**\n   * Set tables for execute-sql operations.\n   *\n   * @param tables - Array of table names\n   * @returns This builder for chaining\n   */\n  tables(tables: string[]): this {\n    this._operation.tables = tables\n    return this\n  }\n\n  /**\n   * Add SQL statement for execute-sql operations.\n   *\n   * @param sql - SQL statement\n   * @param parameters - Optional parameters for the statement\n   * @returns This builder for chaining\n   */\n  statement(sql: string, parameters?: Record<string, string | Expression>): this {\n    if (!this._operation.statements) {\n      this._operation.statements = []\n    }\n    this._operation.statements.push({\n      statement: sql,\n      ...(parameters && { parameters }),\n    })\n    return this\n  }\n\n  /**\n   * Convenience method for execute-sql operations.\n   *\n   * @param tables - Tables affected by SQL statements\n   * @param statements - SQL statements with optional parameters\n   * @returns This builder for chaining\n   */\n  executeSql(\n    tables: string[],\n    ...statements: Array<\n      string | { statement: string; parameters?: Record<string, string | Expression> }\n    >\n  ): this {\n    this._operation.type = 'operation.execute-sql'\n    this._operation.tables = tables\n\n    if (!this._operation.statements) {\n      this._operation.statements = []\n    }\n\n    for (const stmt of statements) {\n      if (typeof stmt === 'string') {\n        this._operation.statements.push({ statement: stmt })\n      } else {\n        this._operation.statements.push(stmt)\n      }\n    }\n\n    return this\n  }\n\n  /**\n   * Convenience method for upsert-merge operations.\n   *\n   * @param table - Target table name or expression\n   * @returns This builder for chaining\n   */\n  upsertMerge(table: string | Expression): this {\n    this._operation.type = 'operation.upsert-merge'\n    this._operation.table =\n      typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table\n    return this\n  }\n\n  /**\n   * Convenience method for upsert-replace operations.\n   *\n   * @param table - Target table name or expression\n   * @returns This builder for chaining\n   */\n  upsertReplace(table: string | Expression): this {\n    this._operation.type = 'operation.upsert-replace'\n    this._operation.table =\n      typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table\n    return this\n  }\n\n  /**\n   * Convenience method for delete-insert operations.\n   *\n   * @param table - Target table name or expression\n   * @returns This builder for chaining\n   */\n  deleteInsert(table: string | Expression): this {\n    this._operation.type = 'operation.delete-insert'\n    this._operation.table =\n      typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table\n    return this\n  }\n\n  /**\n   * Build error operation definition.\n   *\n   * @returns Complete error operation definition object\n   */\n  build(): Record<string, unknown> {\n    return this._operation\n  }\n}\n\n/**\n * Build function error handlers.\n */\nexport class FunctionErrorBuilder {\n  private readonly _error: FunctionErrorHandlerDefinition\n\n  /**\n   * Creates a new error handler builder.\n   *\n   * @param when - Required condition (boolean or expression). Boolean true/false converts to '=true'/'=false'\n   */\n  constructor(when: boolean | string | Expression) {\n    // Convert boolean to expression\n    const whenExpr = typeof when === 'boolean' ? `=${String(when)}` : when\n    this._error = {\n      when: toExpression(whenExpr),\n    }\n  }\n\n  /**\n   * Set error title shown in notifications.\n   *\n   * @param title - Static text, expression (=...), or TextValue\n   * @default title is the same as description if not set.\n   * @returns This builder for chaining\n   */\n  title(title: string | Expression | TextValue | TextValueBuilder): this {\n    if (typeof title === 'string' && title.startsWith('=')) {\n      this._error.title = toExpression(title)\n    } else {\n      this._error.title = TextValueBuilder.from(title)\n    }\n    this._error.description ||= this._error.title\n    return this\n  }\n\n  /**\n   * Set error description for user-facing notifications.\n   *\n   * @param description - Descriptive text or TextValue\n   * @returns This builder for chaining\n   */\n  description(description: string | TextValue | TextValueBuilder): this {\n    this._error.description = TextValueBuilder.from(description)\n    return this\n  }\n\n  /**\n   * Set additional error details.\n   *\n   * @param details - Static text, expression, or TextValue\n   * @returns This builder for chaining\n   */\n  details(details: string | Expression | TextValue | TextValueBuilder): this {\n    if (typeof details === 'string' && details.startsWith('=')) {\n      this._error.details = toExpression(details)\n    } else {\n      this._error.details = TextValueBuilder.from(details)\n    }\n    return this\n  }\n\n  /**\n   * Set icon for error notifications.\n   *\n   * @param icon - Icon name, expression, or IconName type\n   * @returns This builder for chaining\n   */\n  icon(icon: IconName | Expression): this {\n    this._error.icon = toIconNameOrExpression(icon)\n    return this\n  }\n\n  /**\n   * Control whether to show error notification to user.\n   *\n   * @param show - Boolean or expression\n   * @param title\n   * @param description\n   * @default true\n   * @returns This builder for chaining\n   */\n  notification(\n    show: boolean | Expression,\n    title?: string | Expression | TextValue | TextValueBuilder,\n    description?: string | Expression | TextValue | TextValueBuilder,\n  ): this {\n    if (title) this.title(title)\n    if (description) this.description(description)\n    this._error.notification = typeof show === 'boolean' ? show : toExpression(show as string)\n    return this\n  }\n\n  /**\n   * Transform error data before storage/display.\n   *\n   * @param jsonata - JSONATA expression string\n   * @returns This builder for chaining\n   */\n  transform(jsonata: string | Expression): this\n  transform(prefix: string, transform: Record<string, unknown>): this\n  transform(txOrPx: string | Expression, transform?: Record<string, unknown>): this {\n    let tx: string = txOrPx.trimStart()\n    // if (tx.startsWith('=')) tx = tx.slice(1).trimStart()\n    if (transform) tx += JSON.stringify(transform)\n\n    this._error.transform = tx // toExpression(tx)\n    return this\n  }\n\n  /**\n   * Store error data in specified table.\n   *\n   * @param table - Table name or expression\n   * @returns This builder for chaining\n   */\n  table(table: string | Expression): this {\n    this._error.table =\n      typeof table === 'string' && table.startsWith('=') ? toExpression(table) : table\n    return this\n  }\n\n  /**\n   * Add operation to perform when error occurs.\n   *\n   * @param records - JSONATA expression for operation data (optional for execute-sql operations)\n   * @returns ErrorOperationBuilder for further configuration\n   */\n  operation(records?: string | Expression): ErrorOperationBuilder {\n    if (!this._error.operations) {\n      this._error.operations = []\n    }\n\n    const operation: FunctionErrorHandlerOperation = {\n      ...(records !== undefined && { records: toExpression(records) }),\n    }\n    this._error.operations.push(operation)\n\n    return new ErrorOperationBuilder(operation)\n  }\n\n  /**\n   * Configure automatic retry behavior for errors.\n   *\n   * @param config - Retry configuration with when, delay, maxRetries\n   * @returns This builder for chaining\n   */\n  retry(config: FunctionErrorHandlerRetry): this {\n    this._error.retry = {\n      ...(config.when && { when: toExpression(config.when) }),\n      ...(config.delay !== undefined && {\n        delay: typeof config.delay === 'number' ? config.delay : toExpression(config.delay),\n      }),\n      ...(config.maxRetries !== undefined && { maxRetries: config.maxRetries }),\n    }\n    return this\n  }\n\n  /**\n   * Override when condition.\n   *\n   * @param condition - Boolean or JSONATA expression\n   * @returns This builder for chaining\n   */\n  when(condition: boolean | string | Expression): this {\n    const whenExpr = typeof condition === 'boolean' ? `=${String(condition)}` : condition\n    this._error.when = toExpression(whenExpr)\n    return this\n  }\n\n  /**\n   * Configure alert notification for this error handler.\n   *\n   * @param options - Alert configuration\n   * @returns This builder for chaining\n   */\n  alert(options: FunctionErrorHandlerAlert): this {\n    this._error.alert = options\n    return this\n  }\n\n  /**\n   * Build error handler definition.\n   *\n   * @returns Complete error handler definition object\n   */\n  build(): Record<string, unknown> {\n    return this._error\n  }\n}\n"]}