@jigx/core-sdk 1.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"function.abstract.d.ts","sourceRoot":"","sources":["../../src/function/function.abstract.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from 'zod/v4'\nimport {\n  BooleanOrExpressionSchema,\n  BUILD,\n  type ConversionDefinition,\n  ConversionDefinitionSchema,\n  type ConvertFromTo,\n  type DataProvider,\n  DataProviderEnum,\n  type Expression,\n  ExpressionSchema,\n  type FunctionId,\n  FunctionIdSchema,\n  NonExpressionSchema,\n  NumberOrExpressionSchema,\n  ParameterNameDollarSchema,\n  StringOrExpressionSchema,\n  type TableName,\n  TextValueSchema,\n  toEntityName,\n  toFunctionId,\n} from '../abstract/index.js'\nimport { buildTree } from '../abstract/sdk.types.js'\nimport { IconNameSchema } from '../icon/index.js'\nimport { FunctionErrorBuilder } from './function.rest.error-builder.js'\nimport { GuardBuilder } from './function.guard.js'\nimport { OperationBuilder } from './function.operation.js'\n\nconst StatementDefinitionSchema = z.object({\n  statement: z.string(),\n  parameters: z.record(z.string(), StringOrExpressionSchema).optional(),\n})\n\nexport type StatementDefinition = z.infer<typeof StatementDefinitionSchema>\n\n// Operation type enum\nconst OperationTypeEnum = z.enum([\n  'operation.execute-sql',\n  'operation.upsert-merge',\n  'operation.upsert-replace',\n  'operation.delete-insert',\n  'operation.find-replace',\n])\n\nexport type OperationType = z.infer<typeof OperationTypeEnum>\n\nconst FunctionErrorHandlerOperationSchema = z.object({\n  when: ExpressionSchema.optional(),\n  records: ExpressionSchema.optional(),\n  table: StringOrExpressionSchema.optional(),\n  type: OperationTypeEnum.optional(),\n  tables: z.array(z.string()).optional(),\n  statements: z.array(StatementDefinitionSchema).optional(),\n})\n\n// Function error handler types\nexport type FunctionErrorHandlerOperation = z.infer<typeof FunctionErrorHandlerOperationSchema>\n\nconst FunctionErrorHandlerRetrySchema = z.object({\n  when: ExpressionSchema.optional(),\n  delay: NumberOrExpressionSchema.optional(),\n  maxRetries: z.number().int().min(0).optional(),\n})\n\nexport type FunctionErrorHandlerRetry = z.infer<typeof FunctionErrorHandlerRetrySchema>\n\nconst FunctionErrorHandlerAlertSchema = z.object({\n  presentAs: StringOrExpressionSchema.optional(),\n  title: z.union([TextValueSchema, ExpressionSchema]),\n  subtitle: z.union([TextValueSchema, ExpressionSchema]).optional(),\n  description: z.union([TextValueSchema, ExpressionSchema]).optional(),\n  style: z\n    .object({\n      isPositive: BooleanOrExpressionSchema.optional(),\n      isNegative: BooleanOrExpressionSchema.optional(),\n      isWarning: BooleanOrExpressionSchema.optional(),\n    })\n    .optional(),\n  dismiss: z\n    .object({\n      isEnabled: BooleanOrExpressionSchema.optional(),\n      autoAfter: NumberOrExpressionSchema.optional(),\n    })\n    .optional(),\n  icon: z.union([IconNameSchema, ExpressionSchema]).optional(),\n  group: z.object({ id: StringOrExpressionSchema }).optional(),\n  actions: z.array(z.record(z.string(), z.unknown())).optional(),\n  details: z.record(z.string(), z.unknown()).optional(),\n})\n\nexport type FunctionErrorHandlerAlert = z.infer<typeof FunctionErrorHandlerAlertSchema>\n\nconst FunctionErrorHandlerDefinitionSchema = z.object({\n  when: ExpressionSchema.optional(),\n  title: z.union([TextValueSchema, ExpressionSchema]).optional(),\n  description: TextValueSchema.optional(),\n  details: TextValueSchema.optional(),\n  icon: IconNameSchema.optional(),\n  notification: BooleanOrExpressionSchema.optional(),\n  transform: ExpressionSchema.optional(),\n  table: StringOrExpressionSchema.optional(),\n  operations: z.array(FunctionErrorHandlerOperationSchema).optional(),\n  retry: FunctionErrorHandlerRetrySchema.optional(),\n  alert: FunctionErrorHandlerAlertSchema.optional(),\n})\n\nexport type FunctionErrorHandlerDefinition = z.infer<typeof FunctionErrorHandlerDefinitionSchema>\n\n/** @deprecated Use operations instead. */\nconst RowRangeDefinitionSchema = z.object({\n  from: ParameterNameDollarSchema,\n  to: ParameterNameDollarSchema,\n})\n\n/** @deprecated Use operations instead. */\nexport type RowRangeDefinition = z.infer<typeof RowRangeDefinitionSchema>\n\nconst QueryResultTypeEnum = z.enum(['records', 'record', 'scalar'])\n\nexport type QueryResultType = z.infer<typeof QueryResultTypeEnum>\n\nconst QueryDefinitionSchema = z.object({\n  statement: z.string().or(ExpressionSchema),\n  parameters: z.record(z.string(), StringOrExpressionSchema).optional(),\n  resultType: QueryResultTypeEnum.or(ExpressionSchema).optional(),\n  jsonColumns: z.array(z.string()).or(ExpressionSchema).optional(),\n  tables: z.array(z.string()).or(ExpressionSchema).optional(),\n  dependencies: z.array(z.string()).or(ExpressionSchema).optional(),\n  onContinuation: BooleanOrExpressionSchema.optional(),\n})\n\n// Query definition for inline SQLite queries\nexport type QueryDefinition = z.infer<typeof QueryDefinitionSchema>\n\n// Operation schema (shared by guard, root operations, and error operations)\nconst OperationDefinitionSchema = z.object({\n  type: OperationTypeEnum,\n  when: ExpressionSchema.optional(),\n  records: ExpressionSchema.optional(),\n  table: StringOrExpressionSchema.optional(),\n  tables: z.array(z.string()).optional(),\n  statements: z.array(StatementDefinitionSchema).optional(),\n  primaryKey: StringOrExpressionSchema.optional(),\n  timestamp: StringOrExpressionSchema.optional(),\n  conversions: z.array(ConversionDefinitionSchema).optional(),\n  find: StringOrExpressionSchema.optional(),\n  replace: StringOrExpressionSchema.optional(),\n  includeCommandQueue: BooleanOrExpressionSchema.optional(),\n  forRowsWithValues: z.record(z.string(), StringOrExpressionSchema).optional(),\n  forRowsInRange: z\n    .record(\n      z.string(),\n      z.object({\n        from: StringOrExpressionSchema,\n        to: StringOrExpressionSchema,\n      }),\n    )\n    .optional(),\n})\n\nexport type OperationDefinition = z.infer<typeof OperationDefinitionSchema>\n\n// Guard definition for conditional function execution\nconst GuardDefinitionSchema = z.object({\n  function: z.string(),\n  parameters: z.record(z.string(), StringOrExpressionSchema).optional(),\n  when: ExpressionSchema.optional(),\n  onInitial: BooleanOrExpressionSchema.optional(),\n  onRetry: BooleanOrExpressionSchema.optional(),\n  onContinuation: BooleanOrExpressionSchema.optional(),\n  result: ExpressionSchema.optional(),\n  performOperations: BooleanOrExpressionSchema.optional(),\n  operations: z.array(OperationDefinitionSchema).optional(),\n})\n\nexport type GuardDefinition = z.infer<typeof GuardDefinitionSchema>\n\nconst FunctionCoreSchema = z.object({\n  functionId: FunctionIdSchema,\n  provider: DataProviderEnum,\n})\n\n// Function base types\nexport type FunctionCore = z.infer<typeof FunctionCoreSchema>\n\nexport function isFunctionCore(value: unknown): value is FunctionCore {\n  return FunctionCoreSchema.safeParse(value).success\n}\n\nexport const FunctionBaseSchema = FunctionCoreSchema.extend({\n  entity: NonExpressionSchema.optional(),\n  when: BooleanOrExpressionSchema.optional(),\n  guard: GuardDefinitionSchema.optional(),\n  queries: z.record(z.string(), QueryDefinitionSchema).optional(),\n  outputTransform: z.string().optional(),\n\n  /** @deprecated Use operations instead. */\n  forRowsWithMatchingIds: z.boolean().optional(),\n  /** @deprecated Use operations instead. */\n  forRowsWithValues: z.record(z.string(), ParameterNameDollarSchema).optional(),\n  /** @deprecated Use operations instead. */\n  forRowsInRange: z.record(z.string(), RowRangeDefinitionSchema).optional(),\n\n  keepTempIds: z.boolean().optional(),\n  conversions: z.array(ConversionDefinitionSchema).optional(),\n  operations: z.array(OperationDefinitionSchema).optional(),\n  output: ExpressionSchema.optional(),\n  error: z.array(FunctionErrorHandlerDefinitionSchema).optional(),\n})\n\nexport type FunctionBase = z.infer<typeof FunctionBaseSchema>\n\n/**\n * Container for function collections.\n */\nexport interface FunctionsContainer {\n  readonly functions: Record<FunctionId, FunctionBaseBuilder>\n}\n\n/**\n * Build function configurations. Abstract base class.\n */\nexport abstract class FunctionBaseBuilder implements FunctionCore {\n  protected readonly _config: Record<string, unknown> = {}\n  readonly functionId: FunctionId\n  readonly provider: DataProvider\n\n  /**\n   * Create function builder.\n   *\n   * @param functionId - Function identifier\n   * @param provider - Data provider type\n   */\n  protected constructor(functionId: FunctionId, provider: DataProvider) {\n    this.functionId = toFunctionId(functionId)\n    this.provider = provider\n  }\n\n  /**\n   * Add error handling.\n   *\n   * @param when - Condition (boolean or expression)\n   * @returns FunctionErrorBuilder for fluent configuration\n   */\n  error(when: boolean | string | Expression): FunctionErrorBuilder {\n    const builder = new FunctionErrorBuilder(when)\n    if (!Array.isArray(this._config.error)) {\n      this._config.error = []\n    }\n    ;(this._config.error as unknown[]).push(builder)\n    return builder\n  }\n\n  /**\n   * Add guard condition to call another function before execution.\n   *\n   * @param functionId - Function to call for guard evaluation\n   * @returns GuardBuilder for fluent configuration\n   */\n  guard(functionId: FunctionId): GuardBuilder {\n    const builder = new GuardBuilder(functionId)\n    this._config.guard = builder\n    return builder\n  }\n\n  /**\n   * Add root-level operation to execute after function completes.\n   *\n   * @param records - JSONATA expression for operation data (optional for execute-sql)\n   * @returns OperationBuilder for fluent configuration\n   */\n  operation(records?: string | Expression): OperationBuilder {\n    if (!Array.isArray(this._config.operations)) {\n      this._config.operations = []\n    }\n\n    const op: OperationDefinition = {\n      // Placeholder — convenience methods (upsertMerge, executeSql, etc.) set the real\n      // value before build(). OperationDefinitionSchema validates at serialization time.\n      type: '' as OperationType,\n      ...(records && {\n        records: typeof records === 'string' && !records.startsWith('=') ? `=${records}` : records,\n      }),\n    }\n\n    const builder = new OperationBuilder(op)\n    ;(this._config.operations as unknown[]).push(builder)\n    return builder\n  }\n\n  /**\n   * Set guard condition for function execution.\n   *\n   * @param condition - Boolean or expression that determines if function should execute\n   * @returns Builder for chaining\n   */\n  when(condition: boolean | Expression): this {\n    this._config.when = condition\n    return this\n  }\n\n  /**\n   * Add inline SQLite query for local data access.\n   *\n   * @param name - Query identifier for reference in expressions\n   * @param sql - SQL SELECT statement\n   * @param parameters - Optional query parameters\n   * @returns Builder for chaining\n   */\n  query(name: string, sql: string, parameters?: Record<string, string | Expression>): this\n  /**\n   * Add inline SQLite query with advanced configuration.\n   *\n   * @param name - Query identifier for reference in expressions\n   * @param config - Query configuration object\n   * @returns Builder for chaining\n   */\n  query(name: string, config: QueryDefinition): this\n  query(\n    name: string,\n    sqlOrConfig: string | QueryDefinition,\n    parameters?: Record<string, string | Expression>,\n  ): this {\n    if (!this._config.queries) {\n      this._config.queries = {}\n    }\n    const queries = this._config.queries as Record<string, unknown>\n    if (typeof sqlOrConfig === 'string') {\n      queries[name] = {\n        statement: sqlOrConfig,\n        ...(parameters && { parameters }),\n      }\n    } else {\n      const { statement, ...rest } = sqlOrConfig\n      queries[name] = {\n        statement,\n        ...rest,\n      }\n    }\n    return this\n  }\n\n  /**\n   * Set entity name for organizing results.\n   *\n   * @param name - Entity name\n   * @returns Builder for chaining\n   */\n  entity(name: string | TableName): this {\n    this._config.entity = toEntityName(name, false)\n    return this\n  }\n\n  /**\n   * Enable incremental updates. Only update matching IDs.\n   *\n   * @deprecated Use operations instead.\n   * @param value - Enable (default: true)\n   * @returns Builder for chaining\n   */\n  forRowsWithMatchingIds(value = true): this {\n    this._config.forRowsWithMatchingIds = value\n    return this\n  }\n\n  /**\n   * Update rows where column matches parameter.\n   *\n   * @deprecated Use operations instead.\n   * @param column - Column name\n   * @param parameter - Parameter with value\n   * @returns Builder for chaining\n   */\n  forRowsWithValues(column: string, parameter: string): this {\n    if (!this._config.forRowsWithValues) this._config.forRowsWithValues = {}\n    ;(this._config.forRowsWithValues as Record<string, string>)[column] = parameter\n    return this\n  }\n\n  /**\n   * Update rows in range.\n   *\n   * @deprecated Use operations instead.\n   * @param column - Column name\n   * @param from - Start (inclusive)\n   * @param to - End (inclusive)\n   * @returns Builder for chaining\n   */\n  forRowsInRange(column: string, from: string, to: string): this {\n    if (!this._config.forRowsInRange) this._config.forRowsInRange = {}\n    ;(this._config.forRowsInRange as Record<string, unknown>)[column] = { from, to }\n    return this\n  }\n\n  /**\n   * Preserve temporary IDs during sync.\n   *\n   * @param value - Keep temp IDs (default: true)\n   * @returns Builder for chaining\n   */\n  keepTempIds(value = true): this {\n    this._config.keepTempIds = value\n    return this\n  }\n\n  /**\n   * Add data format conversion.\n   *\n   * @param property - Property path\n   * @param from - Source format\n   * @param to - Target format\n   * @param localFilename - Required filename for local-uri\n   * @param convertHeicToJpg - Convert HEIC to JPG\n   * @returns Builder for chaining\n   */\n  conversion(\n    property: string,\n    from: ConvertFromTo,\n    to: 'buffer' | 'base64' | 'data-uri',\n    localFilename?: undefined,\n    convertHeicToJpg?: boolean,\n  ): this\n  conversion(\n    property: string,\n    from: ConvertFromTo,\n    to: 'local-uri',\n    localFilename?: string,\n    convertHeicToJpg?: boolean,\n  ): this\n  conversion(\n    property: string,\n    from: ConvertFromTo,\n    to: ConvertFromTo,\n    localFilename?: string,\n    convertHeicToJpg?: boolean,\n  ): this {\n    if (!Array.isArray(this._config.conversions)) this._config.conversions = []\n    const conversions = this._config.conversions as ConversionDefinition[]\n    if (to !== 'local-uri') {\n      const conversion: ConversionDefinition = {\n        property,\n        from,\n        to,\n      }\n      if (typeof convertHeicToJpg !== 'undefined') {\n        conversion.convertHeicToJpg = convertHeicToJpg\n      }\n      conversions.push(conversion)\n    } else {\n      const conversion: ConversionDefinition = {\n        property,\n        from,\n        to,\n        ...(localFilename && { localFilename }),\n      }\n      if (typeof convertHeicToJpg !== 'undefined') {\n        conversion.convertHeicToJpg = convertHeicToJpg\n      }\n      conversions.push(conversion)\n    }\n    return this\n  }\n\n  /**\n   * Set output expression for function result.\n   *\n   * @param expression - JSONATA expression\n   * @returns Builder for chaining\n   */\n  output(expression: Expression): this {\n    this._config.output = expression\n    return this\n  }\n\n  /**\n   * Transform response with JSONata.\n   *\n   * @param jsonata - JSONata expression\n   * @returns Builder for chaining\n   */\n  outputTransform(jsonata: string | Expression): this\n  outputTransform(prefix: string, transform: Record<string, unknown>): this\n  outputTransform(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.outputTransform = tx\n    return this\n  }\n\n  /**\n   * Build function definition.\n   *\n   * @returns Complete function definition object\n   */\n  build(): Record<string, unknown> {\n    return {\n      functionId: this.functionId,\n      provider: this.provider,\n      ...buildTree(this._config),\n    }\n  }\n\n  // Hidden method to build the function\n  [BUILD](): Record<string, unknown> {\n    return this.build()\n  }\n}\n"]}

package/dist/function/function.abstract.js

@@ -0,0 +1,271 @@
+import { z } from 'zod/v4';
+import { BooleanOrExpressionSchema, BUILD, ConversionDefinitionSchema, DataProviderEnum, ExpressionSchema, FunctionIdSchema, NonExpressionSchema, NumberOrExpressionSchema, ParameterNameDollarSchema, StringOrExpressionSchema, TextValueSchema, toEntityName, toFunctionId, } from '../abstract/index.js';
+import { buildTree } from '../abstract/sdk.types.js';
+import { IconNameSchema } from '../icon/index.js';
+import { FunctionErrorBuilder } from './function.rest.error-builder.js';
+import { GuardBuilder } from './function.guard.js';
+import { OperationBuilder } from './function.operation.js';
+const StatementDefinitionSchema = z.object({
+    statement: z.string(),
+    parameters: z.record(z.string(), StringOrExpressionSchema).optional(),
+});
+const OperationTypeEnum = z.enum([
+    'operation.execute-sql',
+    'operation.upsert-merge',
+    'operation.upsert-replace',
+    'operation.delete-insert',
+    'operation.find-replace',
+]);
+const FunctionErrorHandlerOperationSchema = z.object({
+    when: ExpressionSchema.optional(),
+    records: ExpressionSchema.optional(),
+    table: StringOrExpressionSchema.optional(),
+    type: OperationTypeEnum.optional(),
+    tables: z.array(z.string()).optional(),
+    statements: z.array(StatementDefinitionSchema).optional(),
+});
+const FunctionErrorHandlerRetrySchema = z.object({
+    when: ExpressionSchema.optional(),
+    delay: NumberOrExpressionSchema.optional(),
+    maxRetries: z.number().int().min(0).optional(),
+});
+const FunctionErrorHandlerAlertSchema = z.object({
+    presentAs: StringOrExpressionSchema.optional(),
+    title: z.union([TextValueSchema, ExpressionSchema]),
+    subtitle: z.union([TextValueSchema, ExpressionSchema]).optional(),
+    description: z.union([TextValueSchema, ExpressionSchema]).optional(),
+    style: z
+        .object({
+        isPositive: BooleanOrExpressionSchema.optional(),
+        isNegative: BooleanOrExpressionSchema.optional(),
+        isWarning: BooleanOrExpressionSchema.optional(),
+    })
+        .optional(),
+    dismiss: z
+        .object({
+        isEnabled: BooleanOrExpressionSchema.optional(),
+        autoAfter: NumberOrExpressionSchema.optional(),
+    })
+        .optional(),
+    icon: z.union([IconNameSchema, ExpressionSchema]).optional(),
+    group: z.object({ id: StringOrExpressionSchema }).optional(),
+    actions: z.array(z.record(z.string(), z.unknown())).optional(),
+    details: z.record(z.string(), z.unknown()).optional(),
+});
+const FunctionErrorHandlerDefinitionSchema = z.object({
+    when: ExpressionSchema.optional(),
+    title: z.union([TextValueSchema, ExpressionSchema]).optional(),
+    description: TextValueSchema.optional(),
+    details: TextValueSchema.optional(),
+    icon: IconNameSchema.optional(),
+    notification: BooleanOrExpressionSchema.optional(),
+    transform: ExpressionSchema.optional(),
+    table: StringOrExpressionSchema.optional(),
+    operations: z.array(FunctionErrorHandlerOperationSchema).optional(),
+    retry: FunctionErrorHandlerRetrySchema.optional(),
+    alert: FunctionErrorHandlerAlertSchema.optional(),
+});
+const RowRangeDefinitionSchema = z.object({
+    from: ParameterNameDollarSchema,
+    to: ParameterNameDollarSchema,
+});
+const QueryResultTypeEnum = z.enum(['records', 'record', 'scalar']);
+const QueryDefinitionSchema = z.object({
+    statement: z.string().or(ExpressionSchema),
+    parameters: z.record(z.string(), StringOrExpressionSchema).optional(),
+    resultType: QueryResultTypeEnum.or(ExpressionSchema).optional(),
+    jsonColumns: z.array(z.string()).or(ExpressionSchema).optional(),
+    tables: z.array(z.string()).or(ExpressionSchema).optional(),
+    dependencies: z.array(z.string()).or(ExpressionSchema).optional(),
+    onContinuation: BooleanOrExpressionSchema.optional(),
+});
+const OperationDefinitionSchema = z.object({
+    type: OperationTypeEnum,
+    when: ExpressionSchema.optional(),
+    records: ExpressionSchema.optional(),
+    table: StringOrExpressionSchema.optional(),
+    tables: z.array(z.string()).optional(),
+    statements: z.array(StatementDefinitionSchema).optional(),
+    primaryKey: StringOrExpressionSchema.optional(),
+    timestamp: StringOrExpressionSchema.optional(),
+    conversions: z.array(ConversionDefinitionSchema).optional(),
+    find: StringOrExpressionSchema.optional(),
+    replace: StringOrExpressionSchema.optional(),
+    includeCommandQueue: BooleanOrExpressionSchema.optional(),
+    forRowsWithValues: z.record(z.string(), StringOrExpressionSchema).optional(),
+    forRowsInRange: z
+        .record(z.string(), z.object({
+        from: StringOrExpressionSchema,
+        to: StringOrExpressionSchema,
+    }))
+        .optional(),
+});
+const GuardDefinitionSchema = z.object({
+    function: z.string(),
+    parameters: z.record(z.string(), StringOrExpressionSchema).optional(),
+    when: ExpressionSchema.optional(),
+    onInitial: BooleanOrExpressionSchema.optional(),
+    onRetry: BooleanOrExpressionSchema.optional(),
+    onContinuation: BooleanOrExpressionSchema.optional(),
+    result: ExpressionSchema.optional(),
+    performOperations: BooleanOrExpressionSchema.optional(),
+    operations: z.array(OperationDefinitionSchema).optional(),
+});
+const FunctionCoreSchema = z.object({
+    functionId: FunctionIdSchema,
+    provider: DataProviderEnum,
+});
+export function isFunctionCore(value) {
+    return FunctionCoreSchema.safeParse(value).success;
+}
+export const FunctionBaseSchema = FunctionCoreSchema.extend({
+    entity: NonExpressionSchema.optional(),
+    when: BooleanOrExpressionSchema.optional(),
+    guard: GuardDefinitionSchema.optional(),
+    queries: z.record(z.string(), QueryDefinitionSchema).optional(),
+    outputTransform: z.string().optional(),
+    forRowsWithMatchingIds: z.boolean().optional(),
+    forRowsWithValues: z.record(z.string(), ParameterNameDollarSchema).optional(),
+    forRowsInRange: z.record(z.string(), RowRangeDefinitionSchema).optional(),
+    keepTempIds: z.boolean().optional(),
+    conversions: z.array(ConversionDefinitionSchema).optional(),
+    operations: z.array(OperationDefinitionSchema).optional(),
+    output: ExpressionSchema.optional(),
+    error: z.array(FunctionErrorHandlerDefinitionSchema).optional(),
+});
+export class FunctionBaseBuilder {
+    _config = {};
+    functionId;
+    provider;
+    constructor(functionId, provider) {
+        this.functionId = toFunctionId(functionId);
+        this.provider = provider;
+    }
+    error(when) {
+        const builder = new FunctionErrorBuilder(when);
+        if (!Array.isArray(this._config.error)) {
+            this._config.error = [];
+        }
+        ;
+        this._config.error.push(builder);
+        return builder;
+    }
+    guard(functionId) {
+        const builder = new GuardBuilder(functionId);
+        this._config.guard = builder;
+        return builder;
+    }
+    operation(records) {
+        if (!Array.isArray(this._config.operations)) {
+            this._config.operations = [];
+        }
+        const op = {
+            type: '',
+            ...(records && {
+                records: typeof records === 'string' && !records.startsWith('=') ? `=${records}` : records,
+            }),
+        };
+        const builder = new OperationBuilder(op);
+        this._config.operations.push(builder);
+        return builder;
+    }
+    when(condition) {
+        this._config.when = condition;
+        return this;
+    }
+    query(name, sqlOrConfig, parameters) {
+        if (!this._config.queries) {
+            this._config.queries = {};
+        }
+        const queries = this._config.queries;
+        if (typeof sqlOrConfig === 'string') {
+            queries[name] = {
+                statement: sqlOrConfig,
+                ...(parameters && { parameters }),
+            };
+        }
+        else {
+            const { statement, ...rest } = sqlOrConfig;
+            queries[name] = {
+                statement,
+                ...rest,
+            };
+        }
+        return this;
+    }
+    entity(name) {
+        this._config.entity = toEntityName(name, false);
+        return this;
+    }
+    forRowsWithMatchingIds(value = true) {
+        this._config.forRowsWithMatchingIds = value;
+        return this;
+    }
+    forRowsWithValues(column, parameter) {
+        if (!this._config.forRowsWithValues)
+            this._config.forRowsWithValues = {};
+        this._config.forRowsWithValues[column] = parameter;
+        return this;
+    }
+    forRowsInRange(column, from, to) {
+        if (!this._config.forRowsInRange)
+            this._config.forRowsInRange = {};
+        this._config.forRowsInRange[column] = { from, to };
+        return this;
+    }
+    keepTempIds(value = true) {
+        this._config.keepTempIds = value;
+        return this;
+    }
+    conversion(property, from, to, localFilename, convertHeicToJpg) {
+        if (!Array.isArray(this._config.conversions))
+            this._config.conversions = [];
+        const conversions = this._config.conversions;
+        if (to !== 'local-uri') {
+            const conversion = {
+                property,
+                from,
+                to,
+            };
+            if (typeof convertHeicToJpg !== 'undefined') {
+                conversion.convertHeicToJpg = convertHeicToJpg;
+            }
+            conversions.push(conversion);
+        }
+        else {
+            const conversion = {
+                property,
+                from,
+                to,
+                ...(localFilename && { localFilename }),
+            };
+            if (typeof convertHeicToJpg !== 'undefined') {
+                conversion.convertHeicToJpg = convertHeicToJpg;
+            }
+            conversions.push(conversion);
+        }
+        return this;
+    }
+    output(expression) {
+        this._config.output = expression;
+        return this;
+    }
+    outputTransform(txOrPx, transform) {
+        let tx = txOrPx.trimStart();
+        if (transform)
+            tx += JSON.stringify(transform);
+        this._config.outputTransform = tx;
+        return this;
+    }
+    build() {
+        return {
+            functionId: this.functionId,
+            provider: this.provider,
+            ...buildTree(this._config),
+        };
+    }
+    [BUILD]() {
+        return this.build();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function.abstract.js","sourceRoot":"","sources":["../../src/function/function.abstract.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from 'zod/v4'\nimport {\n  BooleanOrExpressionSchema,\n  BUILD,\n  type ConversionDefinition,\n  ConversionDefinitionSchema,\n  type ConvertFromTo,\n  type DataProvider,\n  DataProviderEnum,\n  type Expression,\n  ExpressionSchema,\n  type FunctionId,\n  FunctionIdSchema,\n  NonExpressionSchema,\n  NumberOrExpressionSchema,\n  ParameterNameDollarSchema,\n  StringOrExpressionSchema,\n  type TableName,\n  TextValueSchema,\n  toEntityName,\n  toFunctionId,\n} from '../abstract/index.js'\nimport { buildTree } from '../abstract/sdk.types.js'\nimport { IconNameSchema } from '../icon/index.js'\nimport { FunctionErrorBuilder } from './function.rest.error-builder.js'\nimport { GuardBuilder } from './function.guard.js'\nimport { OperationBuilder } from './function.operation.js'\n\nconst StatementDefinitionSchema = z.object({\n  statement: z.string(),\n  parameters: z.record(z.string(), StringOrExpressionSchema).optional(),\n})\n\nexport type StatementDefinition = z.infer<typeof StatementDefinitionSchema>\n\n// Operation type enum\nconst OperationTypeEnum = z.enum([\n  'operation.execute-sql',\n  'operation.upsert-merge',\n  'operation.upsert-replace',\n  'operation.delete-insert',\n  'operation.find-replace',\n])\n\nexport type OperationType = z.infer<typeof OperationTypeEnum>\n\nconst FunctionErrorHandlerOperationSchema = z.object({\n  when: ExpressionSchema.optional(),\n  records: ExpressionSchema.optional(),\n  table: StringOrExpressionSchema.optional(),\n  type: OperationTypeEnum.optional(),\n  tables: z.array(z.string()).optional(),\n  statements: z.array(StatementDefinitionSchema).optional(),\n})\n\n// Function error handler types\nexport type FunctionErrorHandlerOperation = z.infer<typeof FunctionErrorHandlerOperationSchema>\n\nconst FunctionErrorHandlerRetrySchema = z.object({\n  when: ExpressionSchema.optional(),\n  delay: NumberOrExpressionSchema.optional(),\n  maxRetries: z.number().int().min(0).optional(),\n})\n\nexport type FunctionErrorHandlerRetry = z.infer<typeof FunctionErrorHandlerRetrySchema>\n\nconst FunctionErrorHandlerAlertSchema = z.object({\n  presentAs: StringOrExpressionSchema.optional(),\n  title: z.union([TextValueSchema, ExpressionSchema]),\n  subtitle: z.union([TextValueSchema, ExpressionSchema]).optional(),\n  description: z.union([TextValueSchema, ExpressionSchema]).optional(),\n  style: z\n    .object({\n      isPositive: BooleanOrExpressionSchema.optional(),\n      isNegative: BooleanOrExpressionSchema.optional(),\n      isWarning: BooleanOrExpressionSchema.optional(),\n    })\n    .optional(),\n  dismiss: z\n    .object({\n      isEnabled: BooleanOrExpressionSchema.optional(),\n      autoAfter: NumberOrExpressionSchema.optional(),\n    })\n    .optional(),\n  icon: z.union([IconNameSchema, ExpressionSchema]).optional(),\n  group: z.object({ id: StringOrExpressionSchema }).optional(),\n  actions: z.array(z.record(z.string(), z.unknown())).optional(),\n  details: z.record(z.string(), z.unknown()).optional(),\n})\n\nexport type FunctionErrorHandlerAlert = z.infer<typeof FunctionErrorHandlerAlertSchema>\n\nconst FunctionErrorHandlerDefinitionSchema = z.object({\n  when: ExpressionSchema.optional(),\n  title: z.union([TextValueSchema, ExpressionSchema]).optional(),\n  description: TextValueSchema.optional(),\n  details: TextValueSchema.optional(),\n  icon: IconNameSchema.optional(),\n  notification: BooleanOrExpressionSchema.optional(),\n  transform: ExpressionSchema.optional(),\n  table: StringOrExpressionSchema.optional(),\n  operations: z.array(FunctionErrorHandlerOperationSchema).optional(),\n  retry: FunctionErrorHandlerRetrySchema.optional(),\n  alert: FunctionErrorHandlerAlertSchema.optional(),\n})\n\nexport type FunctionErrorHandlerDefinition = z.infer<typeof FunctionErrorHandlerDefinitionSchema>\n\n/** @deprecated Use operations instead. */\nconst RowRangeDefinitionSchema = z.object({\n  from: ParameterNameDollarSchema,\n  to: ParameterNameDollarSchema,\n})\n\n/** @deprecated Use operations instead. */\nexport type RowRangeDefinition = z.infer<typeof RowRangeDefinitionSchema>\n\nconst QueryResultTypeEnum = z.enum(['records', 'record', 'scalar'])\n\nexport type QueryResultType = z.infer<typeof QueryResultTypeEnum>\n\nconst QueryDefinitionSchema = z.object({\n  statement: z.string().or(ExpressionSchema),\n  parameters: z.record(z.string(), StringOrExpressionSchema).optional(),\n  resultType: QueryResultTypeEnum.or(ExpressionSchema).optional(),\n  jsonColumns: z.array(z.string()).or(ExpressionSchema).optional(),\n  tables: z.array(z.string()).or(ExpressionSchema).optional(),\n  dependencies: z.array(z.string()).or(ExpressionSchema).optional(),\n  onContinuation: BooleanOrExpressionSchema.optional(),\n})\n\n// Query definition for inline SQLite queries\nexport type QueryDefinition = z.infer<typeof QueryDefinitionSchema>\n\n// Operation schema (shared by guard, root operations, and error operations)\nconst OperationDefinitionSchema = z.object({\n  type: OperationTypeEnum,\n  when: ExpressionSchema.optional(),\n  records: ExpressionSchema.optional(),\n  table: StringOrExpressionSchema.optional(),\n  tables: z.array(z.string()).optional(),\n  statements: z.array(StatementDefinitionSchema).optional(),\n  primaryKey: StringOrExpressionSchema.optional(),\n  timestamp: StringOrExpressionSchema.optional(),\n  conversions: z.array(ConversionDefinitionSchema).optional(),\n  find: StringOrExpressionSchema.optional(),\n  replace: StringOrExpressionSchema.optional(),\n  includeCommandQueue: BooleanOrExpressionSchema.optional(),\n  forRowsWithValues: z.record(z.string(), StringOrExpressionSchema).optional(),\n  forRowsInRange: z\n    .record(\n      z.string(),\n      z.object({\n        from: StringOrExpressionSchema,\n        to: StringOrExpressionSchema,\n      }),\n    )\n    .optional(),\n})\n\nexport type OperationDefinition = z.infer<typeof OperationDefinitionSchema>\n\n// Guard definition for conditional function execution\nconst GuardDefinitionSchema = z.object({\n  function: z.string(),\n  parameters: z.record(z.string(), StringOrExpressionSchema).optional(),\n  when: ExpressionSchema.optional(),\n  onInitial: BooleanOrExpressionSchema.optional(),\n  onRetry: BooleanOrExpressionSchema.optional(),\n  onContinuation: BooleanOrExpressionSchema.optional(),\n  result: ExpressionSchema.optional(),\n  performOperations: BooleanOrExpressionSchema.optional(),\n  operations: z.array(OperationDefinitionSchema).optional(),\n})\n\nexport type GuardDefinition = z.infer<typeof GuardDefinitionSchema>\n\nconst FunctionCoreSchema = z.object({\n  functionId: FunctionIdSchema,\n  provider: DataProviderEnum,\n})\n\n// Function base types\nexport type FunctionCore = z.infer<typeof FunctionCoreSchema>\n\nexport function isFunctionCore(value: unknown): value is FunctionCore {\n  return FunctionCoreSchema.safeParse(value).success\n}\n\nexport const FunctionBaseSchema = FunctionCoreSchema.extend({\n  entity: NonExpressionSchema.optional(),\n  when: BooleanOrExpressionSchema.optional(),\n  guard: GuardDefinitionSchema.optional(),\n  queries: z.record(z.string(), QueryDefinitionSchema).optional(),\n  outputTransform: z.string().optional(),\n\n  /** @deprecated Use operations instead. */\n  forRowsWithMatchingIds: z.boolean().optional(),\n  /** @deprecated Use operations instead. */\n  forRowsWithValues: z.record(z.string(), ParameterNameDollarSchema).optional(),\n  /** @deprecated Use operations instead. */\n  forRowsInRange: z.record(z.string(), RowRangeDefinitionSchema).optional(),\n\n  keepTempIds: z.boolean().optional(),\n  conversions: z.array(ConversionDefinitionSchema).optional(),\n  operations: z.array(OperationDefinitionSchema).optional(),\n  output: ExpressionSchema.optional(),\n  error: z.array(FunctionErrorHandlerDefinitionSchema).optional(),\n})\n\nexport type FunctionBase = z.infer<typeof FunctionBaseSchema>\n\n/**\n * Container for function collections.\n */\nexport interface FunctionsContainer {\n  readonly functions: Record<FunctionId, FunctionBaseBuilder>\n}\n\n/**\n * Build function configurations. Abstract base class.\n */\nexport abstract class FunctionBaseBuilder implements FunctionCore {\n  protected readonly _config: Record<string, unknown> = {}\n  readonly functionId: FunctionId\n  readonly provider: DataProvider\n\n  /**\n   * Create function builder.\n   *\n   * @param functionId - Function identifier\n   * @param provider - Data provider type\n   */\n  protected constructor(functionId: FunctionId, provider: DataProvider) {\n    this.functionId = toFunctionId(functionId)\n    this.provider = provider\n  }\n\n  /**\n   * Add error handling.\n   *\n   * @param when - Condition (boolean or expression)\n   * @returns FunctionErrorBuilder for fluent configuration\n   */\n  error(when: boolean | string | Expression): FunctionErrorBuilder {\n    const builder = new FunctionErrorBuilder(when)\n    if (!Array.isArray(this._config.error)) {\n      this._config.error = []\n    }\n    ;(this._config.error as unknown[]).push(builder)\n    return builder\n  }\n\n  /**\n   * Add guard condition to call another function before execution.\n   *\n   * @param functionId - Function to call for guard evaluation\n   * @returns GuardBuilder for fluent configuration\n   */\n  guard(functionId: FunctionId): GuardBuilder {\n    const builder = new GuardBuilder(functionId)\n    this._config.guard = builder\n    return builder\n  }\n\n  /**\n   * Add root-level operation to execute after function completes.\n   *\n   * @param records - JSONATA expression for operation data (optional for execute-sql)\n   * @returns OperationBuilder for fluent configuration\n   */\n  operation(records?: string | Expression): OperationBuilder {\n    if (!Array.isArray(this._config.operations)) {\n      this._config.operations = []\n    }\n\n    const op: OperationDefinition = {\n      // Placeholder — convenience methods (upsertMerge, executeSql, etc.) set the real\n      // value before build(). OperationDefinitionSchema validates at serialization time.\n      type: '' as OperationType,\n      ...(records && {\n        records: typeof records === 'string' && !records.startsWith('=') ? `=${records}` : records,\n      }),\n    }\n\n    const builder = new OperationBuilder(op)\n    ;(this._config.operations as unknown[]).push(builder)\n    return builder\n  }\n\n  /**\n   * Set guard condition for function execution.\n   *\n   * @param condition - Boolean or expression that determines if function should execute\n   * @returns Builder for chaining\n   */\n  when(condition: boolean | Expression): this {\n    this._config.when = condition\n    return this\n  }\n\n  /**\n   * Add inline SQLite query for local data access.\n   *\n   * @param name - Query identifier for reference in expressions\n   * @param sql - SQL SELECT statement\n   * @param parameters - Optional query parameters\n   * @returns Builder for chaining\n   */\n  query(name: string, sql: string, parameters?: Record<string, string | Expression>): this\n  /**\n   * Add inline SQLite query with advanced configuration.\n   *\n   * @param name - Query identifier for reference in expressions\n   * @param config - Query configuration object\n   * @returns Builder for chaining\n   */\n  query(name: string, config: QueryDefinition): this\n  query(\n    name: string,\n    sqlOrConfig: string | QueryDefinition,\n    parameters?: Record<string, string | Expression>,\n  ): this {\n    if (!this._config.queries) {\n      this._config.queries = {}\n    }\n    const queries = this._config.queries as Record<string, unknown>\n    if (typeof sqlOrConfig === 'string') {\n      queries[name] = {\n        statement: sqlOrConfig,\n        ...(parameters && { parameters }),\n      }\n    } else {\n      const { statement, ...rest } = sqlOrConfig\n      queries[name] = {\n        statement,\n        ...rest,\n      }\n    }\n    return this\n  }\n\n  /**\n   * Set entity name for organizing results.\n   *\n   * @param name - Entity name\n   * @returns Builder for chaining\n   */\n  entity(name: string | TableName): this {\n    this._config.entity = toEntityName(name, false)\n    return this\n  }\n\n  /**\n   * Enable incremental updates. Only update matching IDs.\n   *\n   * @deprecated Use operations instead.\n   * @param value - Enable (default: true)\n   * @returns Builder for chaining\n   */\n  forRowsWithMatchingIds(value = true): this {\n    this._config.forRowsWithMatchingIds = value\n    return this\n  }\n\n  /**\n   * Update rows where column matches parameter.\n   *\n   * @deprecated Use operations instead.\n   * @param column - Column name\n   * @param parameter - Parameter with value\n   * @returns Builder for chaining\n   */\n  forRowsWithValues(column: string, parameter: string): this {\n    if (!this._config.forRowsWithValues) this._config.forRowsWithValues = {}\n    ;(this._config.forRowsWithValues as Record<string, string>)[column] = parameter\n    return this\n  }\n\n  /**\n   * Update rows in range.\n   *\n   * @deprecated Use operations instead.\n   * @param column - Column name\n   * @param from - Start (inclusive)\n   * @param to - End (inclusive)\n   * @returns Builder for chaining\n   */\n  forRowsInRange(column: string, from: string, to: string): this {\n    if (!this._config.forRowsInRange) this._config.forRowsInRange = {}\n    ;(this._config.forRowsInRange as Record<string, unknown>)[column] = { from, to }\n    return this\n  }\n\n  /**\n   * Preserve temporary IDs during sync.\n   *\n   * @param value - Keep temp IDs (default: true)\n   * @returns Builder for chaining\n   */\n  keepTempIds(value = true): this {\n    this._config.keepTempIds = value\n    return this\n  }\n\n  /**\n   * Add data format conversion.\n   *\n   * @param property - Property path\n   * @param from - Source format\n   * @param to - Target format\n   * @param localFilename - Required filename for local-uri\n   * @param convertHeicToJpg - Convert HEIC to JPG\n   * @returns Builder for chaining\n   */\n  conversion(\n    property: string,\n    from: ConvertFromTo,\n    to: 'buffer' | 'base64' | 'data-uri',\n    localFilename?: undefined,\n    convertHeicToJpg?: boolean,\n  ): this\n  conversion(\n    property: string,\n    from: ConvertFromTo,\n    to: 'local-uri',\n    localFilename?: string,\n    convertHeicToJpg?: boolean,\n  ): this\n  conversion(\n    property: string,\n    from: ConvertFromTo,\n    to: ConvertFromTo,\n    localFilename?: string,\n    convertHeicToJpg?: boolean,\n  ): this {\n    if (!Array.isArray(this._config.conversions)) this._config.conversions = []\n    const conversions = this._config.conversions as ConversionDefinition[]\n    if (to !== 'local-uri') {\n      const conversion: ConversionDefinition = {\n        property,\n        from,\n        to,\n      }\n      if (typeof convertHeicToJpg !== 'undefined') {\n        conversion.convertHeicToJpg = convertHeicToJpg\n      }\n      conversions.push(conversion)\n    } else {\n      const conversion: ConversionDefinition = {\n        property,\n        from,\n        to,\n        ...(localFilename && { localFilename }),\n      }\n      if (typeof convertHeicToJpg !== 'undefined') {\n        conversion.convertHeicToJpg = convertHeicToJpg\n      }\n      conversions.push(conversion)\n    }\n    return this\n  }\n\n  /**\n   * Set output expression for function result.\n   *\n   * @param expression - JSONATA expression\n   * @returns Builder for chaining\n   */\n  output(expression: Expression): this {\n    this._config.output = expression\n    return this\n  }\n\n  /**\n   * Transform response with JSONata.\n   *\n   * @param jsonata - JSONata expression\n   * @returns Builder for chaining\n   */\n  outputTransform(jsonata: string | Expression): this\n  outputTransform(prefix: string, transform: Record<string, unknown>): this\n  outputTransform(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.outputTransform = tx\n    return this\n  }\n\n  /**\n   * Build function definition.\n   *\n   * @returns Complete function definition object\n   */\n  build(): Record<string, unknown> {\n    return {\n      functionId: this.functionId,\n      provider: this.provider,\n      ...buildTree(this._config),\n    }\n  }\n\n  // Hidden method to build the function\n  [BUILD](): Record<string, unknown> {\n    return this.build()\n  }\n}\n"]}

package/dist/function/function.guard.d.ts

@@ -0,0 +1,17 @@
+import { type BooleanOrExpression, type Expression, type FunctionId, type ParameterName, type StringOrExpression } from '../abstract/index.js';
+import { OperationBuilder } from './function.operation.js';
+export declare class GuardBuilder {
+    private readonly _guard;
+    constructor(functionId: FunctionId);
+    parameters(parameters: Record<ParameterName, StringOrExpression>): this;
+    parameter(name: ParameterName, value: StringOrExpression): this;
+    when(condition: Expression): this;
+    onInitial(value?: BooleanOrExpression): this;
+    onRetry(value?: BooleanOrExpression): this;
+    onContinuation(value?: BooleanOrExpression): this;
+    result(expression: Expression): this;
+    performOperations(value: BooleanOrExpression): this;
+    operation(records?: Expression): OperationBuilder;
+    build(): Record<string, unknown>;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"function.guard.d.ts","sourceRoot":"","sources":["../../src/function/function.guard.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EACxB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACxB,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAK1D,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IAOxC,YAAY,UAAU,EAAE,UAAU,EAIjC;IAQD,UAAU,CAAC,UAAU,EAAE,MAAM,CAAC,aAAa,EAAE,kBAAkB,CAAC,GAAG,IAAI,CAGtE;IASD,SAAS,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAM9D;IAQD,IAAI,CAAC,SAAS,EAAE,UAAU,GAAG,IAAI,CAGhC;IAQD,SAAS,CAAC,KAAK,GAAE,mBAA0B,GAAG,IAAI,CAIjD;IAQD,OAAO,CAAC,KAAK,GAAE,mBAA0B,GAAG,IAAI,CAG/C;IAQD,cAAc,CAAC,KAAK,GAAE,mBAA0B,GAAG,IAAI,CAItD;IAQD,MAAM,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAGnC;IASD,iBAAiB,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAGlD;IAQD,SAAS,CAAC,OAAO,CAAC,EAAE,UAAU,GAAG,gBAAgB,CAchD;IAOD,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAE/B;CACF","sourcesContent":["import {\n  toBooleanOrExpression,\n  toFunctionId,\n  type BooleanOrExpression,\n  type Expression,\n  type FunctionId,\n  type ParameterName,\n  type StringOrExpression,\n} from '../abstract/index.js'\nimport type { GuardDefinition, OperationDefinition, OperationType } from './function.abstract.js'\nimport { OperationBuilder } from './function.operation.js'\n\n/**\n * Build guard conditions for functions.\n */\nexport class GuardBuilder {\n  private readonly _guard: GuardDefinition\n\n  /**\n   * Creates a new guard builder.\n   *\n   * @param functionId - The function to call for guard evaluation\n   */\n  constructor(functionId: FunctionId) {\n    this._guard = {\n      function: toFunctionId(functionId),\n    }\n  }\n\n  /**\n   * Set parameters to pass to the guard function.\n   *\n   * @param parameters - Parameter values (can include expressions)\n   * @returns This builder for chaining\n   */\n  parameters(parameters: Record<ParameterName, StringOrExpression>): this {\n    this._guard.parameters = parameters\n    return this\n  }\n\n  /**\n   * Add a single parameter to the guard function.\n   *\n   * @param name - Parameter name\n   * @param value - Parameter value or expression\n   * @returns This builder for chaining\n   */\n  parameter(name: ParameterName, value: StringOrExpression): this {\n    if (!this._guard.parameters) {\n      this._guard.parameters = {}\n    }\n    this._guard.parameters[name] = value\n    return this\n  }\n\n  /**\n   * Set condition for when guard should evaluate.\n   *\n   * @param condition - JSONATA expression returning boolean\n   * @returns This builder for chaining\n   */\n  when(condition: Expression): this {\n    this._guard.when = condition\n    return this\n  }\n\n  /**\n   * Set whether guard should execute on initial function call.\n   *\n   * @param value - Boolean or expression (default: true)\n   * @returns This builder for chaining\n   */\n  onInitial(value: BooleanOrExpression = true): this {\n    this._guard.onInitial =\n      typeof value === 'string' && !value.startsWith('=') ? `=${value}` : value\n    return this\n  }\n\n  /**\n   * Set whether guard should execute on retry.\n   *\n   * @param value - Boolean or expression (default: true)\n   * @returns This builder for chaining\n   */\n  onRetry(value: BooleanOrExpression = true): this {\n    this._guard.onRetry = typeof value === 'string' && !value.startsWith('=') ? `=${value}` : value\n    return this\n  }\n\n  /**\n   * Set whether guard should execute on continuation.\n   *\n   * @param value - Boolean or expression (default: true)\n   * @returns This builder for chaining\n   */\n  onContinuation(value: BooleanOrExpression = true): this {\n    this._guard.onContinuation =\n      typeof value === 'string' && !value.startsWith('=') ? `=${value}` : value\n    return this\n  }\n\n  /**\n   * Set the result expression to evaluate guard output.\n   *\n   * @param expression - JSONATA expression returning boolean\n   * @returns This builder for chaining\n   */\n  result(expression: Expression): this {\n    this._guard.result = expression\n    return this\n  }\n\n  /**\n   * Control whether table operations run after the guard function.\n   * By default operations only execute when guard result is false.\n   *\n   * @param value - Boolean or expression\n   * @returns This builder for chaining\n   */\n  performOperations(value: BooleanOrExpression): this {\n    this._guard.performOperations = toBooleanOrExpression(value)\n    return this\n  }\n\n  /**\n   * Add operation to perform based on guard result.\n   *\n   * @param records - JSONATA expression for operation data (optional for execute-sql)\n   * @returns OperationBuilder for further configuration\n   */\n  operation(records?: Expression): OperationBuilder {\n    if (!this._guard.operations) {\n      this._guard.operations = []\n    }\n\n    const operation: OperationDefinition = {\n      // Placeholder — convenience methods (upsertMerge, executeSql, etc.) set the real\n      // value before build(). OperationDefinitionSchema validates at serialization time.\n      type: '' as OperationType,\n      ...(records && { records }),\n    }\n    this._guard.operations.push(operation)\n\n    return new OperationBuilder(operation)\n  }\n\n  /**\n   * Build guard definition.\n   *\n   * @returns Complete guard definition object\n   */\n  build(): Record<string, unknown> {\n    return this._guard\n  }\n}\n"]}

package/dist/function/function.guard.js

@@ -0,0 +1,62 @@
+import { toBooleanOrExpression, toFunctionId, } from '../abstract/index.js';
+import { OperationBuilder } from './function.operation.js';
+export class GuardBuilder {
+    _guard;
+    constructor(functionId) {
+        this._guard = {
+            function: toFunctionId(functionId),
+        };
+    }
+    parameters(parameters) {
+        this._guard.parameters = parameters;
+        return this;
+    }
+    parameter(name, value) {
+        if (!this._guard.parameters) {
+            this._guard.parameters = {};
+        }
+        this._guard.parameters[name] = value;
+        return this;
+    }
+    when(condition) {
+        this._guard.when = condition;
+        return this;
+    }
+    onInitial(value = true) {
+        this._guard.onInitial =
+            typeof value === 'string' && !value.startsWith('=') ? `=${value}` : value;
+        return this;
+    }
+    onRetry(value = true) {
+        this._guard.onRetry = typeof value === 'string' && !value.startsWith('=') ? `=${value}` : value;
+        return this;
+    }
+    onContinuation(value = true) {
+        this._guard.onContinuation =
+            typeof value === 'string' && !value.startsWith('=') ? `=${value}` : value;
+        return this;
+    }
+    result(expression) {
+        this._guard.result = expression;
+        return this;
+    }
+    performOperations(value) {
+        this._guard.performOperations = toBooleanOrExpression(value);
+        return this;
+    }
+    operation(records) {
+        if (!this._guard.operations) {
+            this._guard.operations = [];
+        }
+        const operation = {
+            type: '',
+            ...(records && { records }),
+        };
+        this._guard.operations.push(operation);
+        return new OperationBuilder(operation);
+    }
+    build() {
+        return this._guard;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function.guard.js","sourceRoot":"","sources":["../../src/function/function.guard.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,YAAY,GAMb,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAK1D,MAAM,OAAO,YAAY;IACN,MAAM,CAAiB;IAOxC,YAAY,UAAsB,EAAE;QAClC,IAAI,CAAC,MAAM,GAAG;YACZ,QAAQ,EAAE,YAAY,CAAC,UAAU,CAAC;SACnC,CAAA;IAAA,CACF;IAQD,UAAU,CAAC,UAAqD,EAAQ;QACtE,IAAI,CAAC,MAAM,CAAC,UAAU,GAAG,UAAU,CAAA;QACnC,OAAO,IAAI,CAAA;IAAA,CACZ;IASD,SAAS,CAAC,IAAmB,EAAE,KAAyB,EAAQ;QAC9D,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;YAC5B,IAAI,CAAC,MAAM,CAAC,UAAU,GAAG,EAAE,CAAA;QAC7B,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,CAAA;QACpC,OAAO,IAAI,CAAA;IAAA,CACZ;IAQD,IAAI,CAAC,SAAqB,EAAQ;QAChC,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG,SAAS,CAAA;QAC5B,OAAO,IAAI,CAAA;IAAA,CACZ;IAQD,SAAS,CAAC,KAAK,GAAwB,IAAI,EAAQ;QACjD,IAAI,CAAC,MAAM,CAAC,SAAS;YACnB,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAA;QAC3E,OAAO,IAAI,CAAA;IAAA,CACZ;IAQD,OAAO,CAAC,KAAK,GAAwB,IAAI,EAAQ;QAC/C,IAAI,CAAC,MAAM,CAAC,OAAO,GAAG,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAA;QAC/F,OAAO,IAAI,CAAA;IAAA,CACZ;IAQD,cAAc,CAAC,KAAK,GAAwB,IAAI,EAAQ;QACtD,IAAI,CAAC,MAAM,CAAC,cAAc;YACxB,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAA;QAC3E,OAAO,IAAI,CAAA;IAAA,CACZ;IAQD,MAAM,CAAC,UAAsB,EAAQ;QACnC,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,UAAU,CAAA;QAC/B,OAAO,IAAI,CAAA;IAAA,CACZ;IASD,iBAAiB,CAAC,KAA0B,EAAQ;QAClD,IAAI,CAAC,MAAM,CAAC,iBAAiB,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAA;QAC5D,OAAO,IAAI,CAAA;IAAA,CACZ;IAQD,SAAS,CAAC,OAAoB,EAAoB;QAChD,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;YAC5B,IAAI,CAAC,MAAM,CAAC,UAAU,GAAG,EAAE,CAAA;QAC7B,CAAC;QAED,MAAM,SAAS,GAAwB;YAGrC,IAAI,EAAE,EAAmB;YACzB,GAAG,CAAC,OAAO,IAAI,EAAE,OAAO,EAAE,CAAC;SAC5B,CAAA;QACD,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QAEtC,OAAO,IAAI,gBAAgB,CAAC,SAAS,CAAC,CAAA;IAAA,CACvC;IAOD,KAAK,GAA4B;QAC/B,OAAO,IAAI,CAAC,MAAM,CAAA;IAAA,CACnB;CACF","sourcesContent":["import {\n  toBooleanOrExpression,\n  toFunctionId,\n  type BooleanOrExpression,\n  type Expression,\n  type FunctionId,\n  type ParameterName,\n  type StringOrExpression,\n} from '../abstract/index.js'\nimport type { GuardDefinition, OperationDefinition, OperationType } from './function.abstract.js'\nimport { OperationBuilder } from './function.operation.js'\n\n/**\n * Build guard conditions for functions.\n */\nexport class GuardBuilder {\n  private readonly _guard: GuardDefinition\n\n  /**\n   * Creates a new guard builder.\n   *\n   * @param functionId - The function to call for guard evaluation\n   */\n  constructor(functionId: FunctionId) {\n    this._guard = {\n      function: toFunctionId(functionId),\n    }\n  }\n\n  /**\n   * Set parameters to pass to the guard function.\n   *\n   * @param parameters - Parameter values (can include expressions)\n   * @returns This builder for chaining\n   */\n  parameters(parameters: Record<ParameterName, StringOrExpression>): this {\n    this._guard.parameters = parameters\n    return this\n  }\n\n  /**\n   * Add a single parameter to the guard function.\n   *\n   * @param name - Parameter name\n   * @param value - Parameter value or expression\n   * @returns This builder for chaining\n   */\n  parameter(name: ParameterName, value: StringOrExpression): this {\n    if (!this._guard.parameters) {\n      this._guard.parameters = {}\n    }\n    this._guard.parameters[name] = value\n    return this\n  }\n\n  /**\n   * Set condition for when guard should evaluate.\n   *\n   * @param condition - JSONATA expression returning boolean\n   * @returns This builder for chaining\n   */\n  when(condition: Expression): this {\n    this._guard.when = condition\n    return this\n  }\n\n  /**\n   * Set whether guard should execute on initial function call.\n   *\n   * @param value - Boolean or expression (default: true)\n   * @returns This builder for chaining\n   */\n  onInitial(value: BooleanOrExpression = true): this {\n    this._guard.onInitial =\n      typeof value === 'string' && !value.startsWith('=') ? `=${value}` : value\n    return this\n  }\n\n  /**\n   * Set whether guard should execute on retry.\n   *\n   * @param value - Boolean or expression (default: true)\n   * @returns This builder for chaining\n   */\n  onRetry(value: BooleanOrExpression = true): this {\n    this._guard.onRetry = typeof value === 'string' && !value.startsWith('=') ? `=${value}` : value\n    return this\n  }\n\n  /**\n   * Set whether guard should execute on continuation.\n   *\n   * @param value - Boolean or expression (default: true)\n   * @returns This builder for chaining\n   */\n  onContinuation(value: BooleanOrExpression = true): this {\n    this._guard.onContinuation =\n      typeof value === 'string' && !value.startsWith('=') ? `=${value}` : value\n    return this\n  }\n\n  /**\n   * Set the result expression to evaluate guard output.\n   *\n   * @param expression - JSONATA expression returning boolean\n   * @returns This builder for chaining\n   */\n  result(expression: Expression): this {\n    this._guard.result = expression\n    return this\n  }\n\n  /**\n   * Control whether table operations run after the guard function.\n   * By default operations only execute when guard result is false.\n   *\n   * @param value - Boolean or expression\n   * @returns This builder for chaining\n   */\n  performOperations(value: BooleanOrExpression): this {\n    this._guard.performOperations = toBooleanOrExpression(value)\n    return this\n  }\n\n  /**\n   * Add operation to perform based on guard result.\n   *\n   * @param records - JSONATA expression for operation data (optional for execute-sql)\n   * @returns OperationBuilder for further configuration\n   */\n  operation(records?: Expression): OperationBuilder {\n    if (!this._guard.operations) {\n      this._guard.operations = []\n    }\n\n    const operation: OperationDefinition = {\n      // Placeholder — convenience methods (upsertMerge, executeSql, etc.) set the real\n      // value before build(). OperationDefinitionSchema validates at serialization time.\n      type: '' as OperationType,\n      ...(records && { records }),\n    }\n    this._guard.operations.push(operation)\n\n    return new OperationBuilder(operation)\n  }\n\n  /**\n   * Build guard definition.\n   *\n   * @returns Complete guard definition object\n   */\n  build(): Record<string, unknown> {\n    return this._guard\n  }\n}\n"]}

package/dist/function/function.operation.d.ts

@@ -0,0 +1,26 @@
+import { type BooleanOrExpression, type ConversionDefinition, type Expression, type StringOrExpression, type TableName } from '../abstract/index.js';
+import type { OperationDefinition, OperationType } from './function.abstract.js';
+export declare class OperationBuilder {
+    private readonly _operation;
+    constructor(operation: OperationDefinition);
+    type(operationType: OperationType): this;
+    when(condition: Expression): this;
+    table(table: StringOrExpression): this;
+    tables(tables: TableName[]): this;
+    statement(sql: string, parameters?: Record<string, StringOrExpression>): this;
+    executeSql(tables: TableName[], ...statements: Array<string | {
+        statement: string;
+        parameters?: Record<string, StringOrExpression>;
+    }>): this;
+    upsertMerge(table: StringOrExpression, records: Expression): this;
+    deleteInsert(table: StringOrExpression, records: Expression): this;
+    upsertReplace(table: StringOrExpression, records: Expression): this;
+    findReplace(find: StringOrExpression, replace: StringOrExpression, tables: TableName[], includeCommandQueue?: BooleanOrExpression): this;
+    primaryKey(key: StringOrExpression): this;
+    timestamp(ts: StringOrExpression): this;
+    conversions(conversions: ConversionDefinition[]): this;
+    forRowsWithValues(column: string, value: StringOrExpression): this;
+    forRowsInRange(column: string, from: StringOrExpression, to: StringOrExpression): this;
+    build(): Record<string, unknown>;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function.operation.d.ts","sourceRoot":"","sources":["../../src/function/function.operation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,SAAS,EAEf,MAAM,sBAAsB,CAAA;AAC7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAKhF,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqB;IAOhD,YAAY,SAAS,EAAE,mBAAmB,EAEzC;IAQD,IAAI,CAAC,aAAa,EAAE,aAAa,GAAG,IAAI,CAGvC;IAQD,IAAI,CAAC,SAAS,EAAE,UAAU,GAAG,IAAI,CAGhC;IAQD,KAAK,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAIrC;IAQD,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAGhC;IASD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,GAAG,IAAI,CAS5E;IASD,UAAU,CACR,MAAM,EAAE,SAAS,EAAE,EACnB,GAAG,UAAU,EAAE,KAAK,CAClB,MAAM,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;KAAE,CAChF,GACA,IAAI,CAiBN;IASD,WAAW,CAAC,KAAK,EAAE,kBAAkB,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI,CAKhE;IASD,YAAY,CAAC,KAAK,EAAE,kBAAkB,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI,CAKjE;IASD,aAAa,CAAC,KAAK,EAAE,kBAAkB,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI,CAKlE;IAWD,WAAW,CACT,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,SAAS,EAAE,EACnB,mBAAmB,CAAC,EAAE,mBAAmB,GACxC,IAAI,CAcN;IAQD,UAAU,CAAC,GAAG,EAAE,kBAAkB,GAAG,IAAI,CAIxC;IAQD,SAAS,CAAC,EAAE,EAAE,kBAAkB,GAAG,IAAI,CAGtC;IAQD,WAAW,CAAC,WAAW,EAAE,oBAAoB,EAAE,GAAG,IAAI,CAGrD;IASD,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAOjE;IAUD,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,EAAE,EAAE,EAAE,kBAAkB,GAAG,IAAI,CASrF;IAOD,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAE/B;CACF","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.operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.operation.d.ts","sourceRoot":"","sources":["../../src/function/function.operation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,SAAS,EAEf,MAAM,sBAAsB,CAAA;AAC7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAKhF,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqB;IAOhD,YAAY,SAAS,EAAE,mBAAmB,EAEzC;IAQD,IAAI,CAAC,aAAa,EAAE,aAAa,GAAG,IAAI,CAGvC;IAQD,IAAI,CAAC,SAAS,EAAE,UAAU,GAAG,IAAI,CAGhC;IAQD,KAAK,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAIrC;IAQD,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAGhC;IASD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,GAAG,IAAI,CAS5E;IASD,UAAU,CACR,MAAM,EAAE,SAAS,EAAE,EACnB,GAAG,UAAU,EAAE,KAAK,CAClB,MAAM,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;KAAE,CAChF,GACA,IAAI,CAiBN;IASD,WAAW,CAAC,KAAK,EAAE,kBAAkB,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI,CAKhE;IASD,YAAY,CAAC,KAAK,EAAE,kBAAkB,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI,CAKjE;IASD,aAAa,CAAC,KAAK,EAAE,kBAAkB,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI,CAKlE;IAWD,WAAW,CACT,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,SAAS,EAAE,EACnB,mBAAmB,CAAC,EAAE,mBAAmB,GACxC,IAAI,CAcN;IAQD,UAAU,CAAC,GAAG,EAAE,kBAAkB,GAAG,IAAI,CAIxC;IAQD,SAAS,CAAC,EAAE,EAAE,kBAAkB,GAAG,IAAI,CAGtC;IAQD,WAAW,CAAC,WAAW,EAAE,oBAAoB,EAAE,GAAG,IAAI,CAGrD;IASD,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAOjE;IAUD,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,EAAE,EAAE,EAAE,kBAAkB,GAAG,IAAI,CASrF;IAOD,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAE/B;CACF","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"]}