@tasker-systems/tasker 0.1.5 → 0.1.7

package/dist/index.js

@@ -2458,6 +2458,10 @@ var StepHandler = class {
   /**
    * Version string for the handler.
    * Default: "1.0.0"
+   *
+   * Currently a no-op — not yet wired through FFI bridges to
+   * StepExecutionMetadata. Reserved for future observability
+   * and compatibility tracking.
    */
   static handlerVersion = "1.0.0";
   /**
@@ -2902,6 +2906,34 @@ var APIMixin = class {
 };
 function applyAPI(target) {
   const mixin = new APIMixin();
+  Object.defineProperty(mixin, "baseUrl", {
+    get: () => {
+      const ctor = target.constructor;
+      return ctor.baseUrl || "";
+    }
+  });
+  Object.defineProperty(mixin, "timeout", {
+    get: () => {
+      const ctor = target.constructor;
+      return ctor.defaultTimeout || 3e4;
+    }
+  });
+  Object.defineProperty(mixin, "defaultHeaders", {
+    get: () => {
+      const ctor = target.constructor;
+      return ctor.defaultHeaders || {};
+    }
+  });
+  target.get = mixin.get.bind(mixin);
+  target.post = mixin.post.bind(mixin);
+  target.put = mixin.put.bind(mixin);
+  target.patch = mixin.patch.bind(mixin);
+  target.delete = mixin.delete.bind(mixin);
+  target.request = mixin.request.bind(mixin);
+  target.apiSuccess = mixin.apiSuccess.bind(mixin);
+  target.apiFailure = mixin.apiFailure.bind(mixin);
+  target.connectionError = mixin.connectionError.bind(mixin);
+  target.timeoutError = mixin.timeoutError.bind(mixin);
   Object.defineProperty(target, "baseUrl", {
     get: () => {
       const ctor = target.constructor;
@@ -2920,16 +2952,6 @@ function applyAPI(target) {
       return ctor.defaultHeaders || {};
     }
   });
-  target.get = mixin.get.bind(target);
-  target.post = mixin.post.bind(target);
-  target.put = mixin.put.bind(target);
-  target.patch = mixin.patch.bind(target);
-  target.delete = mixin.delete.bind(target);
-  target.request = mixin.request.bind(target);
-  target.apiSuccess = mixin.apiSuccess.bind(target);
-  target.apiFailure = mixin.apiFailure.bind(target);
-  target.connectionError = mixin.connectionError.bind(target);
-  target.timeoutError = mixin.timeoutError.bind(target);
   return target;
 }
 
@@ -4713,6 +4735,245 @@ function createFfiPollAdapter(module) {
   };
 }
 
+// src/handler/functional.ts
+var PermanentError = class extends Error {
+  retryable = false;
+  metadata;
+  constructor(message, metadata) {
+    super(message);
+    this.name = "PermanentError";
+    this.metadata = metadata ?? {};
+  }
+};
+var RetryableError = class extends Error {
+  retryable = true;
+  metadata;
+  constructor(message, metadata) {
+    super(message);
+    this.name = "RetryableError";
+    this.metadata = metadata ?? {};
+  }
+};
+var Decision = class _Decision {
+  constructor(type, steps, reason, routingContext = {}) {
+    this.type = type;
+    this.steps = steps;
+    this.reason = reason;
+    this.routingContext = routingContext;
+  }
+  /**
+   * Route to the specified steps.
+   */
+  static route(steps, routingContext) {
+    return new _Decision("create_steps", steps, void 0, routingContext ?? {});
+  }
+  /**
+   * Skip all branches.
+   */
+  static skip(reason, routingContext) {
+    return new _Decision("no_branches", [], reason, routingContext ?? {});
+  }
+};
+function wrapResult(result) {
+  if (result instanceof StepHandlerResult) {
+    return result;
+  }
+  if (result != null && typeof result === "object" && !Array.isArray(result)) {
+    return StepHandlerResult.success(result);
+  }
+  if (result == null) {
+    return StepHandlerResult.success({});
+  }
+  return StepHandlerResult.success({ result });
+}
+function wrapError(error) {
+  if (error instanceof PermanentError) {
+    return StepHandlerResult.failure(
+      error.message,
+      "permanent_error" /* PERMANENT_ERROR */,
+      false,
+      error.metadata
+    );
+  }
+  if (error instanceof RetryableError) {
+    return StepHandlerResult.failure(
+      error.message,
+      "retryable_error" /* RETRYABLE_ERROR */,
+      true,
+      error.metadata
+    );
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return StepHandlerResult.failure(message, "handler_error" /* HANDLER_ERROR */, true, {
+    errorType: error instanceof Error ? error.constructor.name : typeof error
+  });
+}
+function injectArgs(context, depends, inputs) {
+  const args = { context };
+  for (const [paramName, stepName] of Object.entries(depends)) {
+    args[paramName] = context.getDependencyResult(stepName);
+  }
+  for (const [paramName, inputKey] of Object.entries(inputs)) {
+    args[paramName] = context.getInput(inputKey);
+  }
+  return args;
+}
+function defineHandler(name, options, fn) {
+  const depends = options.depends ?? {};
+  const inputs = options.inputs ?? {};
+  const version = options.version ?? "1.0.0";
+  const HandlerClass = class extends StepHandler {
+    static handlerName = name;
+    static handlerVersion = version;
+    async call(context) {
+      try {
+        const args = injectArgs(context, depends, inputs);
+        const rawResult = await fn(args);
+        return wrapResult(rawResult);
+      } catch (error) {
+        return wrapError(error);
+      }
+    }
+  };
+  Object.defineProperty(HandlerClass, "name", { value: name });
+  return HandlerClass;
+}
+function defineDecisionHandler(name, options, fn) {
+  const depends = options.depends ?? {};
+  const inputs = options.inputs ?? {};
+  const version = options.version ?? "1.0.0";
+  const HandlerClass = class extends StepHandler {
+    static handlerName = name;
+    static handlerVersion = version;
+    get capabilities() {
+      return ["process", "decision", "routing"];
+    }
+    async call(context) {
+      try {
+        const args = injectArgs(context, depends, inputs);
+        const rawResult = await fn(args);
+        if (rawResult instanceof StepHandlerResult) {
+          return rawResult;
+        }
+        if (rawResult instanceof Decision) {
+          const mixin = new DecisionMixin();
+          Object.defineProperty(mixin, "name", { get: () => name });
+          Object.defineProperty(mixin, "version", { get: () => version });
+          if (rawResult.type === "create_steps") {
+            return mixin.decisionSuccess(rawResult.steps, rawResult.routingContext);
+          }
+          return mixin.skipBranches(rawResult.reason ?? "", rawResult.routingContext);
+        }
+        return wrapResult(rawResult);
+      } catch (error) {
+        return wrapError(error);
+      }
+    }
+  };
+  Object.defineProperty(HandlerClass, "name", { value: name });
+  return HandlerClass;
+}
+function defineBatchAnalyzer(name, options, fn) {
+  const depends = options.depends ?? {};
+  const inputs = options.inputs ?? {};
+  const version = options.version ?? "1.0.0";
+  const workerTemplate = options.workerTemplate;
+  const HandlerClass = class extends StepHandler {
+    static handlerName = name;
+    static handlerVersion = version;
+    async call(context) {
+      try {
+        const args = injectArgs(context, depends, inputs);
+        const rawResult = await fn(args);
+        if (rawResult instanceof StepHandlerResult) {
+          return rawResult;
+        }
+        const config = rawResult;
+        const { totalItems, batchSize } = config;
+        const batchMixin = new BatchableMixin();
+        const cursorRanges = batchMixin.createCursorRanges(totalItems, batchSize);
+        const rustConfigs = cursorRanges.map((c, idx) => ({
+          batch_id: `batch_${String(idx).padStart(3, "0")}`,
+          start_cursor: c.startCursor,
+          end_cursor: c.endCursor,
+          batch_size: c.endCursor - c.startCursor
+        }));
+        const batchProcessingOutcome = createBatches(
+          workerTemplate,
+          rustConfigs.length,
+          rustConfigs,
+          totalItems
+        );
+        return StepHandlerResult.success(
+          { batch_processing_outcome: batchProcessingOutcome },
+          {
+            batch_count: rustConfigs.length,
+            total_items: totalItems,
+            ...config.metadata ?? {}
+          }
+        );
+      } catch (error) {
+        return wrapError(error);
+      }
+    }
+  };
+  Object.defineProperty(HandlerClass, "name", { value: name });
+  return HandlerClass;
+}
+function defineBatchWorker(name, options, fn) {
+  const depends = options.depends ?? {};
+  const inputs = options.inputs ?? {};
+  const version = options.version ?? "1.0.0";
+  const HandlerClass = class extends StepHandler {
+    static handlerName = name;
+    static handlerVersion = version;
+    async call(context) {
+      try {
+        const args = injectArgs(context, depends, inputs);
+        const batchMixin = new BatchableMixin();
+        args.batchContext = batchMixin.getBatchContext(context);
+        const rawResult = await fn(args);
+        return wrapResult(rawResult);
+      } catch (error) {
+        return wrapError(error);
+      }
+    }
+  };
+  Object.defineProperty(HandlerClass, "name", { value: name });
+  return HandlerClass;
+}
+function defineApiHandler(name, options, fn) {
+  const depends = options.depends ?? {};
+  const inputs = options.inputs ?? {};
+  const version = options.version ?? "1.0.0";
+  const apiBaseUrl = options.baseUrl;
+  const apiTimeout = options.defaultTimeout ?? 3e4;
+  const apiHeaders = options.defaultHeaders ?? {};
+  const HandlerClass = class extends StepHandler {
+    static handlerName = name;
+    static handlerVersion = version;
+    static baseUrl = apiBaseUrl;
+    static defaultTimeout = apiTimeout;
+    static defaultHeaders = apiHeaders;
+    constructor() {
+      super();
+      applyAPI(this);
+    }
+    async call(context) {
+      try {
+        const args = injectArgs(context, depends, inputs);
+        args.api = this;
+        const rawResult = await fn(args);
+        return wrapResult(rawResult);
+      } catch (error) {
+        return wrapError(error);
+      }
+    }
+  };
+  Object.defineProperty(HandlerClass, "name", { value: name });
+  return HandlerClass;
+}
+
 // src/registry/errors.ts
 var ResolutionError = class extends Error {
   constructor(message) {
@@ -5419,9 +5680,17 @@ var HandlerSystem = class {
     }
     log5.info(`Loading handlers from: ${path}`, { operation: "load_from_path" });
     try {
+      let totalCount = 0;
       const indexResult = await this.tryImportIndexFile(path);
       if (indexResult.module) {
-        return this.registerHandlersFromModule(indexResult.module, indexResult.path);
+        totalCount += this.registerHandlersFromModule(indexResult.module, indexResult.path);
+      }
+      const dslResult = await this.tryImportDslExamplesIndex(path);
+      if (dslResult.module) {
+        totalCount += this.registerHandlersFromModule(dslResult.module, dslResult.path);
+      }
+      if (totalCount > 0) {
+        return totalCount;
       }
       log5.debug("No index file found, scanning for handler files...", {
         operation: "load_from_path"
@@ -5609,20 +5878,45 @@ var HandlerSystem = class {
     }
     return { module: null, path: null };
   }
+  /**
+   * TAS-294: Try to import the dsl_examples index file.
+   * This is separate from tryImportIndexFile because dsl_examples/ is a sibling
+   * directory to examples/, and both need to be loaded.
+   */
+  async tryImportDslExamplesIndex(handlerPath) {
+    const dslPaths = [
+      join(handlerPath, "dsl_examples", "index.js"),
+      join(handlerPath, "dsl_examples", "index.ts")
+    ];
+    for (const indexPath of dslPaths) {
+      if (existsSync(indexPath)) {
+        const module = await import(`file://${indexPath}`);
+        return { module, path: indexPath };
+      }
+    }
+    return { module: null, path: null };
+  }
   /**
    * Register handlers from a module's exports.
    */
   registerHandlersFromModule(module, importPath) {
     log5.info(`Loaded handler module from: ${importPath}`, { operation: "import_handlers" });
+    let count = 0;
     if (Array.isArray(module.ALL_EXAMPLE_HANDLERS)) {
-      return this.registerFromHandlerArray(module.ALL_EXAMPLE_HANDLERS);
+      count += this.registerFromHandlerArray(module.ALL_EXAMPLE_HANDLERS, "ALL_EXAMPLE_HANDLERS");
+    }
+    if (Array.isArray(module.ALL_DSL_HANDLERS)) {
+      count += this.registerFromHandlerArray(module.ALL_DSL_HANDLERS, "ALL_DSL_HANDLERS");
+    }
+    if (count > 0) {
+      return count;
     }
     return this.registerFromModuleExports(module);
   }
   /**
-   * Register handlers from ALL_EXAMPLE_HANDLERS array.
+   * Register handlers from a named handler array.
    */
-  registerFromHandlerArray(handlers) {
+  registerFromHandlerArray(handlers, arrayName = "ALL_EXAMPLE_HANDLERS") {
     let count = 0;
     for (const handlerClass of handlers) {
       if (this.isValidHandlerClass(handlerClass)) {
@@ -5630,7 +5924,7 @@ var HandlerSystem = class {
         count++;
       }
     }
-    log5.info(`Registered ${count} handlers from ALL_EXAMPLE_HANDLERS`, {
+    log5.info(`Registered ${count} handlers from ${arrayName}`, {
       operation: "import_handlers"
     });
     return count;
@@ -6164,6 +6458,6 @@ var WorkerServer = class {
   }
 };
 
-export { APIMixin, ApiHandler, ApiResponse, BasePublisher, BaseSubscriber, BatchableMixin, ClassLookupResolver, DecisionHandler, DecisionMixin, DecisionType, DefaultPublisher, DuplicatePublisherError, ErrorType, EventNames, EventPoller, EventSystem, ExplicitMappingResolver, FfiLayer, HandlerRegistry, HandlerSystem, InProcessDomainEventPoller, MethodDispatchError, MethodDispatchWrapper, MetricsEventNames, NoResolverMatchError, PollerEventNames, PublisherNotFoundError, PublisherRegistry, PublisherValidationError, RegistryFrozenError, RegistryResolver, ResolutionError, ResolverChain, ResolverNotFoundError, ShutdownController, StepContext, StepEventNames, StepExecutionSubscriber, StepHandler, StepHandlerResult, SubscriberRegistry, TaskerClient, TaskerClientError, TaskerEventEmitter, WorkerEventNames, WorkerServer, aggregateBatchResults, applyAPI, applyBatchable, applyDecision, bootstrapWorker, createBatchWorkerContext, createBatches, createDomainEvent, createEventPoller, createFfiPollAdapter, createLogger, createStepEventContext, effectiveMethod, ffiEventToDomainEvent, fromCallable, fromDto, getRustVersion, getVersion, getWorkerStatus, hasResolverHint, healthCheck, isCreateBatches, isNoBatches, isStandardErrorType, isTypicallyRetryable, isWorkerRunning, logDebug, logError, logInfo, logTrace, logWarn, noBatches, normalizeToDefinition, stopWorker, transitionToGracefulShutdown, usesMethodDispatch };
+export { APIMixin, ApiHandler, ApiResponse, BasePublisher, BaseSubscriber, BatchableMixin, ClassLookupResolver, Decision, DecisionHandler, DecisionMixin, DecisionType, DefaultPublisher, DuplicatePublisherError, ErrorType, EventNames, EventPoller, EventSystem, ExplicitMappingResolver, FfiLayer, HandlerRegistry, HandlerSystem, InProcessDomainEventPoller, MethodDispatchError, MethodDispatchWrapper, MetricsEventNames, NoResolverMatchError, PermanentError, PollerEventNames, PublisherNotFoundError, PublisherRegistry, PublisherValidationError, RegistryFrozenError, RegistryResolver, ResolutionError, ResolverChain, ResolverNotFoundError, RetryableError, ShutdownController, StepContext, StepEventNames, StepExecutionSubscriber, StepHandler, StepHandlerResult, SubscriberRegistry, TaskerClient, TaskerClientError, TaskerEventEmitter, WorkerEventNames, WorkerServer, aggregateBatchResults, applyAPI, applyBatchable, applyDecision, bootstrapWorker, createBatchWorkerContext, createBatches, createDomainEvent, createEventPoller, createFfiPollAdapter, createLogger, createStepEventContext, defineApiHandler, defineBatchAnalyzer, defineBatchWorker, defineDecisionHandler, defineHandler, effectiveMethod, ffiEventToDomainEvent, fromCallable, fromDto, getRustVersion, getVersion, getWorkerStatus, hasResolverHint, healthCheck, isCreateBatches, isNoBatches, isStandardErrorType, isTypicallyRetryable, isWorkerRunning, logDebug, logError, logInfo, logTrace, logWarn, noBatches, normalizeToDefinition, stopWorker, transitionToGracefulShutdown, usesMethodDispatch };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map