@rigkit/engine 0.2.3 → 0.2.4

package/src/provider/types.ts

@@ -82,6 +82,8 @@ export interface WorkflowProviderController<Runtime = unknown> {
 export type ProviderFactoryInput = {
   provider: LoadedProviderDefinition;
   storage: ProviderStorage;
+  hostStorage: ProviderStorage;
+  local: LocalWorkspaceRuntime;
 };
 
 export type ProviderFactory = (

package/src/state.ts

@@ -60,6 +60,10 @@ export interface StateService {
     upstreamRunIds: readonly string[];
   }): WorkflowNodeRunRecord | undefined;
   saveNodeRun(run: WorkflowNodeRunRecord): void;
+  invalidateNodeRuns(input: {
+    workflow: string;
+    nodePaths: readonly string[];
+  }): string[];
   providerStorage(providerId: string): ProviderStorage;
 }
 
@@ -170,6 +174,42 @@ export class StateStore implements StateService {
     this.db.insert(workflowNodeRuns).values(run).run();
   }
 
+  invalidateNodeRuns(input: {
+    workflow: string;
+    nodePaths: readonly string[];
+  }): string[] {
+    const targetPaths = new Set(input.nodePaths);
+    if (targetPaths.size === 0) return [];
+
+    const rows = this.db
+      .select()
+      .from(workflowNodeRuns)
+      .where(eq(workflowNodeRuns.workflow, input.workflow))
+      .orderBy(asc(workflowNodeRuns.createdAt))
+      .all()
+      .map(toNodeRunRecord);
+
+    const invalidatedIds = new Set<string>();
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const row of rows) {
+        if (row.invalidated || invalidatedIds.has(row.id)) continue;
+        const isTarget = targetPaths.has(row.nodePath);
+        const dependsOnInvalidated = row.upstreamRunIds.some((id) => invalidatedIds.has(id));
+        if (!isTarget && !dependsOnInvalidated) continue;
+        invalidatedIds.add(row.id);
+        changed = true;
+      }
+    }
+
+    for (const id of invalidatedIds) {
+      this.db.update(workflowNodeRuns).set({ invalidated: true }).where(eq(workflowNodeRuns.id, id)).run();
+    }
+
+    return [...invalidatedIds];
+  }
+
   providerStorage(providerId: string): ProviderStorage {
     return new StateProviderStorage(this.db, providerId);
   }

package/src/types.ts

@@ -55,13 +55,22 @@ export type CommandOptions = ExecOptions & {
 export type LocalWorkspaceRuntime = {
   open(target: string): MaybePromise<void>;
   command?(input: LocalCommandRequest): MaybePromise<LocalCommandResult>;
-  requestCapability?<Result = unknown>(capability: string, params: unknown): MaybePromise<Result>;
+  requestCapability?<Result = unknown>(
+    capability: string,
+    params: unknown,
+    options?: LocalHostCapabilityRequestOptions,
+  ): MaybePromise<Result>;
   requestCapabilitySession?<Result = unknown>(
     capability: string,
     params: unknown,
+    options?: LocalHostCapabilityRequestOptions,
   ): MaybePromise<HostCapabilitySession<Result>>;
 };
 
+export type LocalHostCapabilityRequestOptions = {
+  nodePath?: string;
+};
+
 export type HostCapabilitySession<Result = unknown> = {
   result: Result;
   closed: Promise<void>;
@@ -133,22 +142,47 @@ export type WorkflowRuntimeHelpers = {
   log(data: string, options?: { stream?: WorkflowLogStream; label?: string }): void;
 };
 
+export const STEP_INVALIDATION_KIND = "rigkit.step.invalidate" as const;
+
+export type WorkflowStepInvalidation<Target extends string = string> = {
+  readonly kind: typeof STEP_INVALIDATION_KIND;
+  readonly target: Target;
+  readonly targetNodePath: string;
+};
+
+export type WorkflowStepRuntime<
+  Context extends JsonObject = JsonObject,
+  PreviousTaskIds extends string = string,
+> = WorkflowRuntimeHelpers & {
+  readonly ctx: Readonly<Context>;
+  invalidate<const Target extends PreviousTaskIds>(target: Target): WorkflowStepInvalidation<Target>;
+};
+
+export type WorkflowTaskContextResult<Context extends JsonObject = JsonObject> = {
+  readonly ctx: Context;
+};
+
 export type WorkflowTaskRuntime<
   Providers extends WorkflowProviderMap,
   Context extends JsonObject,
+  PreviousTaskIds extends string = string,
 > = ProviderRuntimeMap<Providers> & {
   readonly providers: ProviderRuntimeMap<Providers>;
-  readonly ctx: Readonly<Context>;
-  readonly runtime: WorkflowRuntimeHelpers;
+  readonly step: WorkflowStepRuntime<Context, PreviousTaskIds>;
 };
 
-export type WorkflowTaskResult = void | undefined | JsonObject;
+export type WorkflowTaskResult =
+  | void
+  | undefined
+  | WorkflowTaskContextResult<JsonObject>
+  | WorkflowStepInvalidation<string>;
 
 export type WorkflowTaskHandler<
   Providers extends WorkflowProviderMap,
   Context extends JsonObject,
+  PreviousTaskIds extends string = string,
   Result extends WorkflowTaskResult = WorkflowTaskResult,
-> = (context: WorkflowTaskRuntime<Providers, Context>) => MaybePromise<Result>;
+> = (context: WorkflowTaskRuntime<Providers, Context, PreviousTaskIds>) => MaybePromise<Result>;
 
 export type WorkflowInputFieldKind = "workspace" | "string" | "boolean" | "number";
 
@@ -224,6 +258,7 @@ export type WorkflowOperationRuntime<
   readonly providers: ProviderRuntimeMap<Providers>;
   readonly local: LocalWorkspaceRuntime;
   readonly workflow: string;
+  readonly step: WorkflowStepRuntime;
 };
 
 export type WorkflowOperationResult = void | undefined | JsonValue;
@@ -260,6 +295,7 @@ export type WorkflowWorkspaceCreateRuntime<
   readonly workspace: WorkspaceCreateRuntimeRecord;
   readonly providers: ProviderRuntimeMap<Providers>;
   readonly local: LocalWorkspaceRuntime;
+  readonly step: WorkflowStepRuntime;
 };
 
 export type WorkflowWorkspaceCreateHandler<
@@ -277,6 +313,7 @@ export type WorkflowWorkspaceRemoveRuntime<
   readonly workspace: WorkspaceRuntimeRecord<ReadonlyWorkspaceContext<Data>>;
   readonly providers: ProviderRuntimeMap<Providers>;
   readonly local: LocalWorkspaceRuntime;
+  readonly step: WorkflowStepRuntime;
 };
 
 export type WorkflowWorkspaceRemoveHandler<
@@ -296,6 +333,7 @@ export type WorkflowWorkspaceOperationRuntime<
   readonly workspace: WorkspaceRuntimeRecord<Data>;
   readonly providers: ProviderRuntimeMap<Providers>;
   readonly local: LocalWorkspaceRuntime;
+  readonly step: WorkflowStepRuntime;
 };
 
 export type WorkflowWorkspaceOperationHandler<
@@ -372,8 +410,19 @@ export type OutputSchemaValue<Schema> =
 export type WorkflowTaskOptions<Output extends JsonObject = JsonObject> = {
   output?: OutputSchema<Output>;
   version?: string;
+  cacheTTL?: WorkflowTaskCacheTTL;
 };
 
+export type WorkflowTaskCacheTTL =
+  | number
+  | string
+  | {
+      seconds?: number;
+      minutes?: number;
+      hours?: number;
+      days?: number;
+    };
+
 export type WorkflowNodeKind = "task" | "sequence" | "parallel";
 
 export type WorkflowDefinition<
@@ -387,29 +436,39 @@ export type WorkflowDefinition<
   sequence<InputContext extends JsonObject = {}>(name: string): WorkflowSequenceBuilder<
     Providers,
     InputContext,
-    InputContext
+    InputContext,
+    JsonObject,
+    never,
+    never,
+    never
   >;
 
   task<Result extends WorkflowTaskResult>(
     name: string,
-    handler: WorkflowTaskHandler<Providers, {}, Result>,
+    handler: WorkflowTaskHandler<Providers, {}, never, Result>,
   ): WorkflowTaskNode<Providers, {}, TaskReturnContext<Result>>;
 
-  task<Schema extends OutputSchema<JsonObject>, Result extends MaybePromise<OutputSchemaValue<Schema> | void>>(
+  task<
+    Schema extends OutputSchema<JsonObject>,
+    Result extends MaybePromise<WorkflowTaskContextResult<OutputSchemaValue<Schema>> | WorkflowStepInvalidation<string> | void>,
+  >(
     name: string,
     options: WorkflowTaskOptions<OutputSchemaValue<Schema>>,
-    handler: WorkflowTaskHandler<Providers, {}, Awaited<Result> & WorkflowTaskResult>,
+    handler: WorkflowTaskHandler<Providers, {}, never, Awaited<Result> & WorkflowTaskResult>,
   ): WorkflowTaskNode<Providers, {}, TaskReturnContext<Result>>;
 
   step<Result extends WorkflowTaskResult>(
     name: string,
-    handler: WorkflowTaskHandler<Providers, {}, Result>,
+    handler: WorkflowTaskHandler<Providers, {}, never, Result>,
   ): WorkflowTaskNode<Providers, {}, TaskReturnContext<Result>>;
 
-  step<Schema extends OutputSchema<JsonObject>, Result extends MaybePromise<OutputSchemaValue<Schema> | void>>(
+  step<
+    Schema extends OutputSchema<JsonObject>,
+    Result extends MaybePromise<WorkflowTaskContextResult<OutputSchemaValue<Schema>> | WorkflowStepInvalidation<string> | void>,
+  >(
     name: string,
     options: WorkflowTaskOptions<OutputSchemaValue<Schema>>,
-    handler: WorkflowTaskHandler<Providers, {}, Awaited<Result> & WorkflowTaskResult>,
+    handler: WorkflowTaskHandler<Providers, {}, never, Awaited<Result> & WorkflowTaskResult>,
   ): WorkflowTaskNode<Providers, {}, TaskReturnContext<Result>>;
 };
 
@@ -446,7 +505,7 @@ export type WorkflowTaskNode<
 > = WorkflowNodeDefinition<Providers, InputContext, OutputContext> & {
   readonly nodeKind: "task";
   readonly options?: WorkflowTaskOptions;
-  readonly handler: WorkflowTaskHandler<Providers, InputContext, any>;
+  readonly handler: WorkflowTaskHandler<Providers, InputContext, string, any>;
 };
 
 export type WorkflowSequenceBuilder<
@@ -456,58 +515,71 @@ export type WorkflowSequenceBuilder<
   WorkspaceData extends object = JsonObject,
   OperationIds extends string = never,
   WorkspaceOperationIds extends string = never,
+  PreviousTaskIds extends string = never,
 > = WorkflowNodeDefinition<Providers, InputContext, OutputContext> & {
   readonly nodeKind: "sequence";
   readonly children: readonly WorkflowNodeDefinition<Providers, any, any>[];
 
-  task<Result extends WorkflowTaskResult>(
-    name: string,
-    handler: WorkflowTaskHandler<Providers, OutputContext, Result>,
+  task<const Id extends string, Result extends WorkflowTaskResult>(
+    name: Id & WorkflowTaskIdConstraint<Id, PreviousTaskIds>,
+    handler: WorkflowTaskHandler<Providers, OutputContext, PreviousTaskIds, Result>,
   ): WorkflowSequenceBuilder<
     Providers,
     InputContext,
-    Merge<OutputContext, TaskReturnContext<Result>>,
+    TaskReturnContext<Result>,
     WorkspaceData,
     OperationIds,
-    WorkspaceOperationIds
+    WorkspaceOperationIds,
+    PreviousTaskIds | Id
   >;
 
-  task<Schema extends OutputSchema<JsonObject>, Result extends MaybePromise<OutputSchemaValue<Schema> | void>>(
-    name: string,
+  task<
+    const Id extends string,
+    Schema extends OutputSchema<JsonObject>,
+    Result extends MaybePromise<WorkflowTaskContextResult<OutputSchemaValue<Schema>> | WorkflowStepInvalidation<string> | void>,
+  >(
+    name: Id & WorkflowTaskIdConstraint<Id, PreviousTaskIds>,
     options: WorkflowTaskOptions<OutputSchemaValue<Schema>>,
-    handler: WorkflowTaskHandler<Providers, OutputContext, Awaited<Result> & WorkflowTaskResult>,
+    handler: WorkflowTaskHandler<Providers, OutputContext, PreviousTaskIds, Awaited<Result> & WorkflowTaskResult>,
   ): WorkflowSequenceBuilder<
     Providers,
     InputContext,
-    Merge<OutputContext, TaskReturnContext<Result>>,
+    TaskReturnContext<Result>,
     WorkspaceData,
     OperationIds,
-    WorkspaceOperationIds
+    WorkspaceOperationIds,
+    PreviousTaskIds | Id
   >;
 
-  step<Result extends WorkflowTaskResult>(
-    name: string,
-    handler: WorkflowTaskHandler<Providers, OutputContext, Result>,
+  step<const Id extends string, Result extends WorkflowTaskResult>(
+    name: Id & WorkflowTaskIdConstraint<Id, PreviousTaskIds>,
+    handler: WorkflowTaskHandler<Providers, OutputContext, PreviousTaskIds, Result>,
   ): WorkflowSequenceBuilder<
     Providers,
     InputContext,
-    Merge<OutputContext, TaskReturnContext<Result>>,
+    TaskReturnContext<Result>,
     WorkspaceData,
     OperationIds,
-    WorkspaceOperationIds
+    WorkspaceOperationIds,
+    PreviousTaskIds | Id
   >;
 
-  step<Schema extends OutputSchema<JsonObject>, Result extends MaybePromise<OutputSchemaValue<Schema> | void>>(
-    name: string,
+  step<
+    const Id extends string,
+    Schema extends OutputSchema<JsonObject>,
+    Result extends MaybePromise<WorkflowTaskContextResult<OutputSchemaValue<Schema>> | WorkflowStepInvalidation<string> | void>,
+  >(
+    name: Id & WorkflowTaskIdConstraint<Id, PreviousTaskIds>,
     options: WorkflowTaskOptions<OutputSchemaValue<Schema>>,
-    handler: WorkflowTaskHandler<Providers, OutputContext, Awaited<Result> & WorkflowTaskResult>,
+    handler: WorkflowTaskHandler<Providers, OutputContext, PreviousTaskIds, Awaited<Result> & WorkflowTaskResult>,
   ): WorkflowSequenceBuilder<
     Providers,
     InputContext,
-    Merge<OutputContext, TaskReturnContext<Result>>,
+    TaskReturnContext<Result>,
     WorkspaceData,
     OperationIds,
-    WorkspaceOperationIds
+    WorkspaceOperationIds,
+    PreviousTaskIds | Id
   >;
 
   add<Node extends WorkflowNodeDefinition<Providers, any, any>>(
@@ -515,10 +587,11 @@ export type WorkflowSequenceBuilder<
   ): WorkflowSequenceBuilder<
     Providers,
     InputContext,
-    Merge<OutputContext, WorkflowNodeOutput<Node>>,
+    WorkflowNodeOutput<Node>,
     WorkspaceData,
     OperationIds,
-    WorkspaceOperationIds
+    WorkspaceOperationIds,
+    PreviousTaskIds
   >;
 
   parallel<const Branches extends Record<string, WorkflowNodeDefinition<Providers, any, any>>>(
@@ -533,7 +606,8 @@ export type WorkflowSequenceBuilder<
     Merge<OutputContext, ParallelOutput<Branches>>,
     WorkspaceData,
     OperationIds,
-    WorkspaceOperationIds
+    WorkspaceOperationIds,
+    PreviousTaskIds
   >;
 
   workspace<Data extends JsonObject>(
@@ -544,7 +618,8 @@ export type WorkflowSequenceBuilder<
     OutputContext,
     ReadonlyWorkspaceContext<Data>,
     OperationIds,
-    WorkspaceOperationIds
+    WorkspaceOperationIds,
+    PreviousTaskIds
   >;
 
   operation<const Id extends string, Input extends object = {}>(
@@ -556,7 +631,8 @@ export type WorkflowSequenceBuilder<
     OutputContext,
     WorkspaceData,
     OperationIds | Id,
-    WorkspaceOperationIds
+    WorkspaceOperationIds,
+    PreviousTaskIds
   >;
 
   workspaceOperation<const Id extends string, Input extends object = {}>(
@@ -568,7 +644,8 @@ export type WorkflowSequenceBuilder<
     OutputContext,
     WorkspaceData,
     OperationIds,
-    WorkspaceOperationIds | Id
+    WorkspaceOperationIds | Id,
+    PreviousTaskIds
   >;
 };
 
@@ -607,6 +684,21 @@ export type WorkflowOperationIdConstraint<
         ? WorkflowOperationIdError<`Operation id "${Id}" cannot contain "/"`>
         : unknown;
 
+type WorkflowTaskIdError<Message extends string> = {
+  readonly __rigkitTaskIdError: Message;
+};
+
+export type WorkflowTaskIdConstraint<
+  Id extends string,
+  Existing extends string,
+> = string extends Id
+  ? unknown
+  : Id extends Existing
+    ? WorkflowTaskIdError<`Task id "${Id}" is already defined`>
+    : Id extends ""
+      ? WorkflowTaskIdError<"Task ids must be non-empty">
+      : unknown;
+
 export type WorkflowNodeInput<Node> =
   Node extends WorkflowNodeDefinition<any, infer Input extends JsonObject, any>
     ? Input
@@ -621,13 +713,14 @@ export type ParallelOutput<Branches extends Record<string, WorkflowNodeDefinitio
   [Key in keyof Branches & string]: WorkflowNodeOutput<Branches[Key]>;
 };
 
-export type TaskReturnContext<Return> = Exclude<Awaited<Return>, void | undefined> extends infer Context
-  ? [Context] extends [never]
-    ? {}
-    : Context extends JsonObject
-      ? Context
-      : never
-  : {};
+export type TaskReturnContext<Return> =
+  Exclude<Awaited<Return>, void | undefined | WorkflowStepInvalidation<string>> extends infer Result
+    ? [Result] extends [never]
+      ? {}
+      : Result extends { ctx: infer Context extends JsonObject }
+        ? Simplify<Context>
+        : never
+    : {};
 
 export type Merge<Left extends JsonObject, Right extends JsonObject> =
   Simplify<Omit<Left, keyof Right> & Right>;

package/src/version.ts

@@ -1 +1 @@
-export const RIGKIT_ENGINE_VERSION = "0.2.3";
+export const RIGKIT_ENGINE_VERSION = "0.2.4";