@aigne/afs-domain-action 1.11.0-beta.6

package/LICENSE.md

@@ -0,0 +1,26 @@
+# Proprietary License
+
+Copyright (c) 2024-2025 ArcBlock, Inc. All Rights Reserved.
+
+This software and associated documentation files (the "Software") are proprietary
+and confidential. Unauthorized copying, modification, distribution, or use of
+this Software, via any medium, is strictly prohibited.
+
+The Software is provided for internal use only within ArcBlock, Inc. and its
+authorized affiliates.
+
+## No License Granted
+
+No license, express or implied, is granted to any party for any purpose.
+All rights are reserved by ArcBlock, Inc.
+
+## Public Artifact Distribution
+
+Portions of this Software may be released publicly under separate open-source
+licenses (such as MIT License) through designated public repositories. Such
+public releases are governed by their respective licenses and do not affect
+the proprietary nature of this repository.
+
+## Contact
+
+For licensing inquiries, contact: legal@arcblock.io

package/dist/index.d.mts

@@ -0,0 +1,574 @@
+import { z } from "zod";
+
+//#region src/types.d.ts
+declare const EffectSchema: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+  write: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+  write: string;
+}, {
+  write: string;
+}>, {
+  type: "write";
+  kind: string;
+}, {
+  write: string;
+}>, z.ZodEffects<z.ZodObject<{
+  delete: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+  delete: string;
+}, {
+  delete: string;
+}>, {
+  type: "delete";
+  kind: string;
+}, {
+  delete: string;
+}>, z.ZodEffects<z.ZodObject<{
+  call: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+  call: string;
+}, {
+  call: string;
+}>, {
+  type: "call";
+  provider: string;
+}, {
+  call: string;
+}>]>;
+type EffectSpec = z.output<typeof EffectSchema>;
+declare const ConstraintSchema: z.ZodEffects<z.ZodObject<{
+  requires: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+  requires: string;
+}, {
+  requires: string;
+}>, {
+  type: "authenticated";
+  role?: undefined;
+} | {
+  type: "role";
+  role: string | undefined;
+}, {
+  requires: string;
+}>;
+type ConstraintSpec = z.output<typeof ConstraintSchema>;
+declare const AutoFieldSchema: z.ZodUnion<[z.ZodEffects<z.ZodNumber, {
+  type: "literal";
+  value: number;
+}, number>, z.ZodEffects<z.ZodBoolean, {
+  type: "literal";
+  value: boolean;
+}, boolean>, z.ZodEffects<z.ZodString, {
+  type: "time";
+  key?: undefined;
+  field?: undefined;
+  value?: undefined;
+} | {
+  type: "context";
+  key: string;
+  field?: undefined;
+  value?: undefined;
+} | {
+  type: "input";
+  field: string;
+  key?: undefined;
+  value?: undefined;
+} | {
+  type: "literal";
+  value: string;
+  key?: undefined;
+  field?: undefined;
+}, string>]>;
+type AutoFieldSpec = z.output<typeof AutoFieldSchema>;
+declare class ActionErrorClass extends Error {
+  name: string;
+}
+declare const InputSchemaSpec: z.ZodRecord<z.ZodString, z.ZodString>;
+type InputSchema = z.output<typeof InputSchemaSpec>;
+declare const OutputSchemaSpec: z.ZodRecord<z.ZodString, z.ZodString>;
+type OutputSchema = z.output<typeof OutputSchemaSpec>;
+declare const ActionSpecSchema: z.ZodObject<{
+  level: z.ZodOptional<z.ZodEnum<["declarative", "imperative"]>>;
+  description: z.ZodString;
+  input: z.ZodRecord<z.ZodString, z.ZodString>;
+  output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  effects: z.ZodArray<z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+    write: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    write: string;
+  }, {
+    write: string;
+  }>, {
+    type: "write";
+    kind: string;
+  }, {
+    write: string;
+  }>, z.ZodEffects<z.ZodObject<{
+    delete: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    delete: string;
+  }, {
+    delete: string;
+  }>, {
+    type: "delete";
+    kind: string;
+  }, {
+    delete: string;
+  }>, z.ZodEffects<z.ZodObject<{
+    call: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    call: string;
+  }, {
+    call: string;
+  }>, {
+    type: "call";
+    provider: string;
+  }, {
+    call: string;
+  }>]>, "many">;
+  constraints: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
+    requires: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    requires: string;
+  }, {
+    requires: string;
+  }>, {
+    type: "authenticated";
+    role?: undefined;
+  } | {
+    type: "role";
+    role: string | undefined;
+  }, {
+    requires: string;
+  }>, "many">>;
+  executor: z.ZodOptional<z.ZodString>;
+  auto: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodEffects<z.ZodNumber, {
+    type: "literal";
+    value: number;
+  }, number>, z.ZodEffects<z.ZodBoolean, {
+    type: "literal";
+    value: boolean;
+  }, boolean>, z.ZodEffects<z.ZodString, {
+    type: "time";
+    key?: undefined;
+    field?: undefined;
+    value?: undefined;
+  } | {
+    type: "context";
+    key: string;
+    field?: undefined;
+    value?: undefined;
+  } | {
+    type: "input";
+    field: string;
+    key?: undefined;
+    value?: undefined;
+  } | {
+    type: "literal";
+    value: string;
+    key?: undefined;
+    field?: undefined;
+  }, string>]>>>;
+}, "strip", z.ZodTypeAny, {
+  input: Record<string, string>;
+  description: string;
+  effects: ({
+    type: "write";
+    kind: string;
+  } | {
+    type: "delete";
+    kind: string;
+  } | {
+    type: "call";
+    provider: string;
+  })[];
+  level?: "declarative" | "imperative" | undefined;
+  output?: Record<string, string> | undefined;
+  constraints?: ({
+    type: "authenticated";
+    role?: undefined;
+  } | {
+    type: "role";
+    role: string | undefined;
+  })[] | undefined;
+  executor?: string | undefined;
+  auto?: Record<string, {
+    type: "literal";
+    value: number;
+  } | {
+    type: "literal";
+    value: boolean;
+  } | {
+    type: "time";
+    key?: undefined;
+    field?: undefined;
+    value?: undefined;
+  } | {
+    type: "context";
+    key: string;
+    field?: undefined;
+    value?: undefined;
+  } | {
+    type: "input";
+    field: string;
+    key?: undefined;
+    value?: undefined;
+  } | {
+    type: "literal";
+    value: string;
+    key?: undefined;
+    field?: undefined;
+  }> | undefined;
+}, {
+  input: Record<string, string>;
+  description: string;
+  effects: ({
+    write: string;
+  } | {
+    delete: string;
+  } | {
+    call: string;
+  })[];
+  level?: "declarative" | "imperative" | undefined;
+  output?: Record<string, string> | undefined;
+  constraints?: {
+    requires: string;
+  }[] | undefined;
+  executor?: string | undefined;
+  auto?: Record<string, string | number | boolean> | undefined;
+}>;
+type ActionSpec = z.output<typeof ActionSpecSchema>;
+declare const DomainSpecSchema: z.ZodObject<{
+  domain: z.ZodString;
+  actions: z.ZodRecord<z.ZodString, z.ZodObject<{
+    level: z.ZodOptional<z.ZodEnum<["declarative", "imperative"]>>;
+    description: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodString>;
+    output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    effects: z.ZodArray<z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+      write: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+      write: string;
+    }, {
+      write: string;
+    }>, {
+      type: "write";
+      kind: string;
+    }, {
+      write: string;
+    }>, z.ZodEffects<z.ZodObject<{
+      delete: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+      delete: string;
+    }, {
+      delete: string;
+    }>, {
+      type: "delete";
+      kind: string;
+    }, {
+      delete: string;
+    }>, z.ZodEffects<z.ZodObject<{
+      call: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+      call: string;
+    }, {
+      call: string;
+    }>, {
+      type: "call";
+      provider: string;
+    }, {
+      call: string;
+    }>]>, "many">;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
+      requires: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+      requires: string;
+    }, {
+      requires: string;
+    }>, {
+      type: "authenticated";
+      role?: undefined;
+    } | {
+      type: "role";
+      role: string | undefined;
+    }, {
+      requires: string;
+    }>, "many">>;
+    executor: z.ZodOptional<z.ZodString>;
+    auto: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodEffects<z.ZodNumber, {
+      type: "literal";
+      value: number;
+    }, number>, z.ZodEffects<z.ZodBoolean, {
+      type: "literal";
+      value: boolean;
+    }, boolean>, z.ZodEffects<z.ZodString, {
+      type: "time";
+      key?: undefined;
+      field?: undefined;
+      value?: undefined;
+    } | {
+      type: "context";
+      key: string;
+      field?: undefined;
+      value?: undefined;
+    } | {
+      type: "input";
+      field: string;
+      key?: undefined;
+      value?: undefined;
+    } | {
+      type: "literal";
+      value: string;
+      key?: undefined;
+      field?: undefined;
+    }, string>]>>>;
+  }, "strip", z.ZodTypeAny, {
+    input: Record<string, string>;
+    description: string;
+    effects: ({
+      type: "write";
+      kind: string;
+    } | {
+      type: "delete";
+      kind: string;
+    } | {
+      type: "call";
+      provider: string;
+    })[];
+    level?: "declarative" | "imperative" | undefined;
+    output?: Record<string, string> | undefined;
+    constraints?: ({
+      type: "authenticated";
+      role?: undefined;
+    } | {
+      type: "role";
+      role: string | undefined;
+    })[] | undefined;
+    executor?: string | undefined;
+    auto?: Record<string, {
+      type: "literal";
+      value: number;
+    } | {
+      type: "literal";
+      value: boolean;
+    } | {
+      type: "time";
+      key?: undefined;
+      field?: undefined;
+      value?: undefined;
+    } | {
+      type: "context";
+      key: string;
+      field?: undefined;
+      value?: undefined;
+    } | {
+      type: "input";
+      field: string;
+      key?: undefined;
+      value?: undefined;
+    } | {
+      type: "literal";
+      value: string;
+      key?: undefined;
+      field?: undefined;
+    }> | undefined;
+  }, {
+    input: Record<string, string>;
+    description: string;
+    effects: ({
+      write: string;
+    } | {
+      delete: string;
+    } | {
+      call: string;
+    })[];
+    level?: "declarative" | "imperative" | undefined;
+    output?: Record<string, string> | undefined;
+    constraints?: {
+      requires: string;
+    }[] | undefined;
+    executor?: string | undefined;
+    auto?: Record<string, string | number | boolean> | undefined;
+  }>>;
+}, "strip", z.ZodTypeAny, {
+  domain: string;
+  actions: Record<string, {
+    input: Record<string, string>;
+    description: string;
+    effects: ({
+      type: "write";
+      kind: string;
+    } | {
+      type: "delete";
+      kind: string;
+    } | {
+      type: "call";
+      provider: string;
+    })[];
+    level?: "declarative" | "imperative" | undefined;
+    output?: Record<string, string> | undefined;
+    constraints?: ({
+      type: "authenticated";
+      role?: undefined;
+    } | {
+      type: "role";
+      role: string | undefined;
+    })[] | undefined;
+    executor?: string | undefined;
+    auto?: Record<string, {
+      type: "literal";
+      value: number;
+    } | {
+      type: "literal";
+      value: boolean;
+    } | {
+      type: "time";
+      key?: undefined;
+      field?: undefined;
+      value?: undefined;
+    } | {
+      type: "context";
+      key: string;
+      field?: undefined;
+      value?: undefined;
+    } | {
+      type: "input";
+      field: string;
+      key?: undefined;
+      value?: undefined;
+    } | {
+      type: "literal";
+      value: string;
+      key?: undefined;
+      field?: undefined;
+    }> | undefined;
+  }>;
+}, {
+  domain: string;
+  actions: Record<string, {
+    input: Record<string, string>;
+    description: string;
+    effects: ({
+      write: string;
+    } | {
+      delete: string;
+    } | {
+      call: string;
+    })[];
+    level?: "declarative" | "imperative" | undefined;
+    output?: Record<string, string> | undefined;
+    constraints?: {
+      requires: string;
+    }[] | undefined;
+    executor?: string | undefined;
+    auto?: Record<string, string | number | boolean> | undefined;
+  }>;
+}>;
+type DomainSpec = z.output<typeof DomainSpecSchema>;
+//#endregion
+//#region src/effects.d.ts
+interface WorldInterface {
+  read(kind: string, id: string): Promise<unknown>;
+  list(kind: string): Promise<unknown[]>;
+  write(kind: string, id: string, data: unknown): Promise<void>;
+  delete(kind: string, id: string): Promise<void>;
+}
+type CallFn = (provider: string, args: unknown) => Promise<unknown>;
+declare function createWorldProxy(world: WorldInterface, declaredEffects: EffectSpec[]): WorldInterface;
+declare function createCallProxy(callFn: CallFn, declaredEffects: EffectSpec[]): CallFn;
+//#endregion
+//#region src/autogen.d.ts
+interface ExecutionPlan {
+  type: "create" | "update" | "delete";
+  kind: string;
+}
+declare function compileExecutionPlan(spec: ActionSpec): ExecutionPlan;
+interface AutoContext {
+  did: string;
+  now: Date;
+}
+declare function resolveAutoFields(auto: Record<string, AutoFieldSpec> | undefined, input: Record<string, unknown>, ctx: AutoContext): Record<string, unknown>;
+interface ExecuteContext {
+  world: WorldInterface;
+  input: Record<string, unknown>;
+  caller: AutoContext;
+  genId: () => string;
+  auto?: Record<string, AutoFieldSpec>;
+}
+declare function executeAutoPlan(plan: ExecutionPlan, ctx: ExecuteContext): Promise<{
+  id: string;
+}>;
+//#endregion
+//#region src/constraints.d.ts
+interface CallerInfo {
+  did: string | null;
+  roles: string[];
+}
+declare function checkConstraints(constraints: ConstraintSpec[], caller: CallerInfo): void;
+//#endregion
+//#region src/executor.d.ts
+interface ActionContext {
+  world: WorldInterface;
+  call: CallFn;
+  now: () => string;
+  id: {
+    gen: () => string;
+  };
+  caller: CallerInfo;
+  error: (message: string) => ActionErrorClass;
+}
+type ExecutorFunction = (ctx: ActionContext, input: Record<string, unknown>) => Promise<unknown>;
+interface ActionContextOptions {
+  world: WorldInterface;
+  callFn: CallFn;
+  caller: CallerInfo;
+  now: Date;
+  genId: () => string;
+}
+declare function createActionContext(opts: ActionContextOptions): ActionContext;
+declare function loadExecutor(executorPath: string, basePath: string): Promise<ExecutorFunction>;
+declare function executeImperative(executor: ExecutorFunction, ctx: ActionContext, input: Record<string, unknown>): Promise<unknown>;
+//#endregion
+//#region src/orchestrator.d.ts
+interface DomainExecutorOptions {
+  spec: DomainSpec;
+  world: WorldInterface;
+  executorsBase: string;
+  genId: () => string;
+  callFn?: (provider: string, args: unknown) => Promise<unknown>;
+}
+interface ExecInput {
+  input: Record<string, unknown>;
+  caller: CallerInfo;
+}
+type DomainExecutorFn = (actionName: string, opts: ExecInput) => Promise<unknown>;
+declare function createDomainExecutor(options: DomainExecutorOptions): DomainExecutorFn;
+//#endregion
+//#region src/parser.d.ts
+/**
+ * Parse a YAML string containing domain action specs into a validated DomainSpec.
+ */
+declare function parseDomainSpec(yamlContent: string): DomainSpec;
+//#endregion
+//#region src/registry.d.ts
+interface RegistryEntry {
+  name: string;
+  spec: ActionSpec;
+}
+declare class ActionRegistry {
+  private actions;
+  private _domain;
+  get domain(): string;
+  load(spec: DomainSpec): void;
+  get(name: string): ActionSpec;
+  list(): RegistryEntry[];
+}
+/**
+ * Build a Zod validator from ActionSpec.input and validate the given input.
+ * Optional fields (type ending with "?") become z.string().optional().
+ * Strict mode: extra fields are rejected.
+ */
+declare function validateInput(spec: ActionSpec, input: unknown): Record<string, unknown>;
+//#endregion
+export { type ActionContext, type ActionContextOptions, ActionErrorClass, ActionRegistry, type ActionSpec, ActionSpecSchema, type AutoContext, AutoFieldSchema, type AutoFieldSpec, type CallFn, type CallerInfo, ConstraintSchema, type ConstraintSpec, type DomainExecutorFn, type DomainExecutorOptions, type DomainSpec, DomainSpecSchema, EffectSchema, type EffectSpec, type ExecInput, type ExecuteContext, type ExecutionPlan, type ExecutorFunction, type InputSchema, InputSchemaSpec, type OutputSchema, OutputSchemaSpec, type RegistryEntry, type WorldInterface, checkConstraints, compileExecutionPlan, createActionContext, createCallProxy, createDomainExecutor, createWorldProxy, executeAutoPlan, executeImperative, loadExecutor, parseDomainSpec, resolveAutoFields, validateInput };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/effects.ts","../src/autogen.ts","../src/constraints.ts","../src/executor.ts","../src/orchestrator.ts","../src/parser.ts","../src/registry.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -0,0 +1,306 @@
+import { z } from "zod";
+import { parse } from "yaml";
+
+//#region src/types.ts
+const WriteEffectSchema = z.object({ write: z.string() }).transform((v) => ({
+	type: "write",
+	kind: v.write
+}));
+const DeleteEffectSchema = z.object({ delete: z.string() }).transform((v) => ({
+	type: "delete",
+	kind: v.delete
+}));
+const CallEffectSchema = z.object({ call: z.string() }).transform((v) => ({
+	type: "call",
+	provider: v.call
+}));
+const EffectSchema = z.union([
+	WriteEffectSchema,
+	DeleteEffectSchema,
+	CallEffectSchema
+]);
+const RequiresSchema = z.object({ requires: z.string() }).transform((v) => {
+	if (v.requires === "authenticated") return { type: "authenticated" };
+	const roleMatch = v.requires.match(/^role\((\w+)\)$/);
+	if (roleMatch) return {
+		type: "role",
+		role: roleMatch[1]
+	};
+	throw new Error(`Invalid constraint: "${v.requires}". Only "authenticated" and "role(xxx)" are allowed.`);
+});
+const ConstraintSchema = RequiresSchema;
+const AutoFieldSchema = z.union([
+	z.number().transform((v) => ({
+		type: "literal",
+		value: v
+	})),
+	z.boolean().transform((v) => ({
+		type: "literal",
+		value: v
+	})),
+	z.string().transform((v) => {
+		if (v === "@now") return { type: "time" };
+		if (v.startsWith("@")) return {
+			type: "context",
+			key: v.slice(1)
+		};
+		if (v.startsWith("input.")) return {
+			type: "input",
+			field: v.slice(6)
+		};
+		return {
+			type: "literal",
+			value: v
+		};
+	})
+]);
+var ActionErrorClass = class extends Error {
+	name = "ActionError";
+};
+const InputFieldTypeSchema = z.string();
+const InputSchemaSpec = z.record(z.string(), InputFieldTypeSchema);
+const OutputSchemaSpec = z.record(z.string(), InputFieldTypeSchema);
+const ActionSpecSchema = z.object({
+	level: z.enum(["declarative", "imperative"]).optional(),
+	description: z.string(),
+	input: InputSchemaSpec,
+	output: OutputSchemaSpec.optional(),
+	effects: z.array(EffectSchema).min(1),
+	constraints: z.array(ConstraintSchema).optional(),
+	executor: z.string().optional(),
+	auto: z.record(z.string(), AutoFieldSchema).optional()
+});
+const DomainSpecSchema = z.object({
+	domain: z.string(),
+	actions: z.record(z.string(), ActionSpecSchema)
+});
+
+//#endregion
+//#region src/autogen.ts
+function compileExecutionPlan(spec) {
+	const writes = spec.effects.filter((e) => e.type === "write");
+	const deletes = spec.effects.filter((e) => e.type === "delete");
+	if (spec.effects.filter((e) => e.type === "call").length > 0 || writes.length + deletes.length !== 1) throw new ActionErrorClass("cannot auto-generate for actions with multiple or mixed effects");
+	if (writes.length === 1) {
+		const kind = writes[0].kind;
+		return {
+			type: "id" in spec.input ? "update" : "create",
+			kind
+		};
+	}
+	return {
+		type: "delete",
+		kind: deletes[0].kind
+	};
+}
+function resolveAutoFields(auto, input, ctx) {
+	const result = { ...input };
+	if (!auto) return result;
+	for (const [field, spec] of Object.entries(auto)) if (spec.type === "literal") result[field] = spec.value;
+	else if (spec.type === "input") result[field] = input[spec.field];
+	else if (spec.type === "context") result[field] = ctx.did;
+	else if (spec.type === "time") result[field] = ctx.now.toISOString();
+	return result;
+}
+async function executeAutoPlan(plan, ctx) {
+	const { world, input, caller, genId } = ctx;
+	if (plan.type === "create") {
+		const id$1 = genId();
+		const data = {
+			id: id$1,
+			...resolveAutoFields(ctx.auto, input, caller)
+		};
+		await world.write(plan.kind, id$1, data);
+		return { id: id$1 };
+	}
+	if (plan.type === "update") {
+		const id$1 = input.id;
+		const existing = await world.read(plan.kind, id$1);
+		const { id: _id, ...updates } = input;
+		const merged = {
+			...existing,
+			...updates
+		};
+		await world.write(plan.kind, id$1, merged);
+		return { id: id$1 };
+	}
+	const id = input.id;
+	await world.delete(plan.kind, id);
+	return { id };
+}
+
+//#endregion
+//#region src/constraints.ts
+function checkConstraints(constraints, caller) {
+	for (const constraint of constraints) if (constraint.type === "authenticated") {
+		if (!caller.did) throw new ActionErrorClass("Authentication required");
+	} else if (constraint.type === "role") {
+		const role = constraint.role;
+		if (!caller.roles.includes(role)) throw new ActionErrorClass(`Missing role: ${role}`);
+	}
+}
+
+//#endregion
+//#region src/effects.ts
+function createWorldProxy(world, declaredEffects) {
+	const writeKinds = new Set(declaredEffects.filter((e) => e.type === "write").map((e) => e.kind));
+	const deleteKinds = new Set(declaredEffects.filter((e) => e.type === "delete").map((e) => e.kind));
+	return {
+		read: (kind, id) => world.read(kind, id),
+		list: (kind) => world.list(kind),
+		async write(kind, id, data) {
+			if (!writeKinds.has(kind)) throw new ActionErrorClass(`Effect not declared: write ${kind}`);
+			return world.write(kind, id, data);
+		},
+		async delete(kind, id) {
+			if (!deleteKinds.has(kind)) throw new ActionErrorClass(`Effect not declared: delete ${kind}`);
+			return world.delete(kind, id);
+		}
+	};
+}
+function createCallProxy(callFn, declaredEffects) {
+	const allowedProviders = new Set(declaredEffects.filter((e) => e.type === "call").map((e) => e.provider));
+	return async (provider, args) => {
+		if (!allowedProviders.has(provider)) throw new ActionErrorClass(`Effect not declared: call ${provider}`);
+		return callFn(provider, args);
+	};
+}
+
+//#endregion
+//#region src/executor.ts
+function createActionContext(opts) {
+	const frozenNow = opts.now.toISOString();
+	return {
+		world: opts.world,
+		call: opts.callFn,
+		now: () => frozenNow,
+		id: { gen: opts.genId },
+		caller: opts.caller,
+		error: (message) => new ActionErrorClass(message)
+	};
+}
+async function loadExecutor(executorPath, basePath) {
+	const fullPath = new URL(executorPath, `file://${basePath}/`).pathname;
+	let mod;
+	try {
+		mod = await import(fullPath);
+	} catch {
+		throw new ActionErrorClass(`Executor not found: ${executorPath}`);
+	}
+	if (typeof mod.default !== "function") throw new ActionErrorClass("Executor must have default export");
+	return mod.default;
+}
+async function executeImperative(executor, ctx, input) {
+	try {
+		return await executor(ctx, input);
+	} catch (e) {
+		if (e instanceof ActionErrorClass) throw e;
+		throw new Error(`System error in executor: ${e.message}`);
+	}
+}
+
+//#endregion
+//#region src/registry.ts
+var ActionRegistry = class {
+	actions = /* @__PURE__ */ new Map();
+	_domain = "";
+	get domain() {
+		return this._domain;
+	}
+	load(spec) {
+		this._domain = spec.domain;
+		this.actions.clear();
+		for (const [name, actionSpec] of Object.entries(spec.actions)) this.actions.set(name, actionSpec);
+	}
+	get(name) {
+		const spec = this.actions.get(name);
+		if (!spec) throw new ActionErrorClass(`Unknown action: ${name}`);
+		return spec;
+	}
+	list() {
+		return [...this.actions.entries()].map(([name, spec]) => ({
+			name,
+			spec
+		}));
+	}
+};
+/**
+* Build a Zod validator from ActionSpec.input and validate the given input.
+* Optional fields (type ending with "?") become z.string().optional().
+* Strict mode: extra fields are rejected.
+*/
+function validateInput(spec, input) {
+	const shape = {};
+	for (const [field, typeStr] of Object.entries(spec.input)) {
+		const isOptional = typeStr.endsWith("?");
+		const baseSchema = z.string();
+		shape[field] = isOptional ? baseSchema.optional() : baseSchema;
+	}
+	return z.object(shape).strict().parse(input);
+}
+
+//#endregion
+//#region src/orchestrator.ts
+function createDomainExecutor(options) {
+	const registry = new ActionRegistry();
+	registry.load(options.spec);
+	const executorCache = /* @__PURE__ */ new Map();
+	const defaultCallFn = options.callFn ?? (async () => {
+		throw new Error("No call provider configured");
+	});
+	return async (actionName, opts) => {
+		if (actionName === "list-actions") return registry.list().map((e) => ({
+			name: e.name,
+			description: e.spec.description,
+			level: e.spec.level
+		}));
+		const spec = registry.get(actionName);
+		if (spec.constraints) checkConstraints(spec.constraints, opts.caller);
+		const validatedInput = validateInput(spec, opts.input);
+		const worldProxy = createWorldProxy(options.world, spec.effects);
+		const callProxy = createCallProxy(defaultCallFn, spec.effects);
+		const now = /* @__PURE__ */ new Date();
+		if (spec.executor) {
+			let executor = executorCache.get(spec.executor);
+			if (!executor) {
+				executor = await loadExecutor(spec.executor, options.executorsBase);
+				executorCache.set(spec.executor, executor);
+			}
+			const ctx = createActionContext({
+				world: worldProxy,
+				callFn: callProxy,
+				caller: opts.caller,
+				now,
+				genId: options.genId
+			});
+			return executeImperative(executor, ctx, validatedInput);
+		}
+		return executeAutoPlan(compileExecutionPlan(spec), {
+			world: worldProxy,
+			input: resolveAutoFields(spec.auto, validatedInput, {
+				did: opts.caller.did ?? "",
+				now
+			}),
+			caller: {
+				did: opts.caller.did ?? "",
+				now
+			},
+			genId: options.genId,
+			auto: spec.auto
+		});
+	};
+}
+
+//#endregion
+//#region src/parser.ts
+/**
+* Parse a YAML string containing domain action specs into a validated DomainSpec.
+*/
+function parseDomainSpec(yamlContent) {
+	const raw = parse(yamlContent);
+	return DomainSpecSchema.parse(raw);
+}
+
+//#endregion
+export { ActionErrorClass, ActionRegistry, ActionSpecSchema, AutoFieldSchema, ConstraintSchema, DomainSpecSchema, EffectSchema, InputSchemaSpec, OutputSchemaSpec, checkConstraints, compileExecutionPlan, createActionContext, createCallProxy, createDomainExecutor, createWorldProxy, executeAutoPlan, executeImperative, loadExecutor, parseDomainSpec, resolveAutoFields, validateInput };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["id","parseYaml"],"sources":["../src/types.ts","../src/autogen.ts","../src/constraints.ts","../src/effects.ts","../src/executor.ts","../src/registry.ts","../src/orchestrator.ts","../src/parser.ts"],"sourcesContent":["import { z } from \"zod\";\n\n// --- Effects ---\n\nconst WriteEffectSchema = z\n  .object({ write: z.string() })\n  .transform((v) => ({ type: \"write\" as const, kind: v.write }));\n\nconst DeleteEffectSchema = z\n  .object({ delete: z.string() })\n  .transform((v) => ({ type: \"delete\" as const, kind: v.delete }));\n\nconst CallEffectSchema = z\n  .object({ call: z.string() })\n  .transform((v) => ({ type: \"call\" as const, provider: v.call }));\n\nexport const EffectSchema = z.union([WriteEffectSchema, DeleteEffectSchema, CallEffectSchema]);\n\nexport type EffectSpec = z.output<typeof EffectSchema>;\n\n// --- Constraints ---\n\nconst RequiresSchema = z.object({ requires: z.string() }).transform((v) => {\n  // Try authenticated first\n  if (v.requires === \"authenticated\") {\n    return { type: \"authenticated\" as const };\n  }\n  // Try role(xxx)\n  const roleMatch = v.requires.match(/^role\\((\\w+)\\)$/);\n  if (roleMatch) {\n    return { type: \"role\" as const, role: roleMatch[1] };\n  }\n  throw new Error(\n    `Invalid constraint: \"${v.requires}\". Only \"authenticated\" and \"role(xxx)\" are allowed.`,\n  );\n});\n\nexport const ConstraintSchema = RequiresSchema;\n\nexport type ConstraintSpec = z.output<typeof ConstraintSchema>;\n\n// --- Auto Fields ---\n\nexport const AutoFieldSchema = z.union([\n  z.number().transform((v) => ({ type: \"literal\" as const, value: v })),\n  z.boolean().transform((v) => ({ type: \"literal\" as const, value: v })),\n  z.string().transform((v) => {\n    if (v === \"@now\") return { type: \"time\" as const };\n    if (v.startsWith(\"@\")) return { type: \"context\" as const, key: v.slice(1) };\n    if (v.startsWith(\"input.\")) return { type: \"input\" as const, field: v.slice(6) };\n    return { type: \"literal\" as const, value: v };\n  }),\n]);\n\nexport type AutoFieldSpec = z.output<typeof AutoFieldSchema>;\n\n// --- ActionError ---\n\nexport class ActionErrorClass extends Error {\n  override name = \"ActionError\";\n}\n\n// --- Input/Output Schema ---\n\nexport const InputFieldTypeSchema = z.string(); // \"string\", \"text\", \"string?\", \"ref:Identity\", etc.\n\nexport const InputSchemaSpec = z.record(z.string(), InputFieldTypeSchema);\nexport type InputSchema = z.output<typeof InputSchemaSpec>;\n\nexport const OutputSchemaSpec = z.record(z.string(), InputFieldTypeSchema);\nexport type OutputSchema = z.output<typeof OutputSchemaSpec>;\n\n// --- ActionSpec ---\n\nexport const ActionSpecSchema = z.object({\n  level: z.enum([\"declarative\", \"imperative\"]).optional(),\n  description: z.string(),\n  input: InputSchemaSpec,\n  output: OutputSchemaSpec.optional(),\n  effects: z.array(EffectSchema).min(1),\n  constraints: z.array(ConstraintSchema).optional(),\n  executor: z.string().optional(),\n  auto: z.record(z.string(), AutoFieldSchema).optional(),\n});\n\nexport type ActionSpec = z.output<typeof ActionSpecSchema>;\n\n// --- DomainSpec ---\n\nexport const DomainSpecSchema = z.object({\n  domain: z.string(),\n  actions: z.record(z.string(), ActionSpecSchema),\n});\n\nexport type DomainSpec = z.output<typeof DomainSpecSchema>;\n","import type { WorldInterface } from \"./effects.js\";\nimport type { ActionSpec, AutoFieldSpec } from \"./types.js\";\nimport { ActionErrorClass } from \"./types.js\";\n\n// --- Execution Plan ---\n\nexport interface ExecutionPlan {\n  type: \"create\" | \"update\" | \"delete\";\n  kind: string;\n}\n\nexport function compileExecutionPlan(spec: ActionSpec): ExecutionPlan {\n  const writes = spec.effects.filter((e) => e.type === \"write\");\n  const deletes = spec.effects.filter((e) => e.type === \"delete\");\n  const calls = spec.effects.filter((e) => e.type === \"call\");\n\n  // Can only auto-gen for single-effect actions (one write OR one delete, no calls)\n  if (calls.length > 0 || writes.length + deletes.length !== 1) {\n    throw new ActionErrorClass(\"cannot auto-generate for actions with multiple or mixed effects\");\n  }\n\n  if (writes.length === 1) {\n    const kind = (writes[0] as { type: \"write\"; kind: string }).kind;\n    const hasId = \"id\" in spec.input;\n    return { type: hasId ? \"update\" : \"create\", kind };\n  }\n\n  const kind = (deletes[0] as { type: \"delete\"; kind: string }).kind;\n  return { type: \"delete\", kind };\n}\n\n// --- Auto Field Resolution ---\n\nexport interface AutoContext {\n  did: string;\n  now: Date;\n}\n\nexport function resolveAutoFields(\n  auto: Record<string, AutoFieldSpec> | undefined,\n  input: Record<string, unknown>,\n  ctx: AutoContext,\n): Record<string, unknown> {\n  const result = { ...input };\n\n  if (!auto) return result;\n\n  for (const [field, spec] of Object.entries(auto)) {\n    if (spec.type === \"literal\") {\n      result[field] = spec.value;\n    } else if (spec.type === \"input\") {\n      result[field] = input[(spec as { type: \"input\"; field: string }).field];\n    } else if (spec.type === \"context\") {\n      // For now, context key \"current_user_did\" maps to caller DID\n      result[field] = ctx.did;\n    } else if (spec.type === \"time\") {\n      result[field] = ctx.now.toISOString();\n    }\n  }\n\n  return result;\n}\n\n// --- Execute Auto Plan ---\n\nexport interface ExecuteContext {\n  world: WorldInterface;\n  input: Record<string, unknown>;\n  caller: AutoContext;\n  genId: () => string;\n  auto?: Record<string, AutoFieldSpec>;\n}\n\nexport async function executeAutoPlan(\n  plan: ExecutionPlan,\n  ctx: ExecuteContext,\n): Promise<{ id: string }> {\n  const { world, input, caller, genId } = ctx;\n\n  if (plan.type === \"create\") {\n    const id = genId();\n    const data = { id, ...resolveAutoFields(ctx.auto, input, caller) };\n    await world.write(plan.kind, id, data);\n    return { id };\n  }\n\n  if (plan.type === \"update\") {\n    const id = input.id as string;\n    const existing = (await world.read(plan.kind, id)) as Record<string, unknown>;\n    const { id: _id, ...updates } = input;\n    const merged = { ...existing, ...updates };\n    await world.write(plan.kind, id, merged);\n    return { id };\n  }\n\n  // delete\n  const id = input.id as string;\n  await world.delete(plan.kind, id);\n  return { id };\n}\n","import type { ConstraintSpec } from \"./types.js\";\nimport { ActionErrorClass } from \"./types.js\";\n\nexport interface CallerInfo {\n  did: string | null;\n  roles: string[];\n}\n\nexport function checkConstraints(constraints: ConstraintSpec[], caller: CallerInfo): void {\n  for (const constraint of constraints) {\n    if (constraint.type === \"authenticated\") {\n      if (!caller.did) {\n        throw new ActionErrorClass(\"Authentication required\");\n      }\n    } else if (constraint.type === \"role\") {\n      const role = (constraint as { type: \"role\"; role: string }).role;\n      if (!caller.roles.includes(role)) {\n        throw new ActionErrorClass(`Missing role: ${role}`);\n      }\n    }\n  }\n}\n","import type { EffectSpec } from \"./types.js\";\nimport { ActionErrorClass } from \"./types.js\";\n\nexport interface WorldInterface {\n  read(kind: string, id: string): Promise<unknown>;\n  list(kind: string): Promise<unknown[]>;\n  write(kind: string, id: string, data: unknown): Promise<void>;\n  delete(kind: string, id: string): Promise<void>;\n}\n\nexport type CallFn = (provider: string, args: unknown) => Promise<unknown>;\n\nexport function createWorldProxy(\n  world: WorldInterface,\n  declaredEffects: EffectSpec[],\n): WorldInterface {\n  const writeKinds = new Set(\n    declaredEffects\n      .filter((e) => e.type === \"write\")\n      .map((e) => (e as { type: \"write\"; kind: string }).kind),\n  );\n  const deleteKinds = new Set(\n    declaredEffects\n      .filter((e) => e.type === \"delete\")\n      .map((e) => (e as { type: \"delete\"; kind: string }).kind),\n  );\n\n  return {\n    read: (kind, id) => world.read(kind, id),\n    list: (kind) => world.list(kind),\n    async write(kind, id, data) {\n      if (!writeKinds.has(kind)) {\n        throw new ActionErrorClass(`Effect not declared: write ${kind}`);\n      }\n      return world.write(kind, id, data);\n    },\n    async delete(kind, id) {\n      if (!deleteKinds.has(kind)) {\n        throw new ActionErrorClass(`Effect not declared: delete ${kind}`);\n      }\n      return world.delete(kind, id);\n    },\n  };\n}\n\nexport function createCallProxy(callFn: CallFn, declaredEffects: EffectSpec[]): CallFn {\n  const allowedProviders = new Set(\n    declaredEffects\n      .filter((e) => e.type === \"call\")\n      .map((e) => (e as { type: \"call\"; provider: string }).provider),\n  );\n\n  return async (provider, args) => {\n    if (!allowedProviders.has(provider)) {\n      throw new ActionErrorClass(`Effect not declared: call ${provider}`);\n    }\n    return callFn(provider, args);\n  };\n}\n","import type { CallerInfo } from \"./constraints.js\";\nimport type { CallFn, WorldInterface } from \"./effects.js\";\nimport { ActionErrorClass } from \"./types.js\";\n\nexport interface ActionContext {\n  world: WorldInterface;\n  call: CallFn;\n  now: () => string;\n  id: { gen: () => string };\n  caller: CallerInfo;\n  error: (message: string) => ActionErrorClass;\n}\n\nexport type ExecutorFunction = (\n  ctx: ActionContext,\n  input: Record<string, unknown>,\n) => Promise<unknown>;\n\nexport interface ActionContextOptions {\n  world: WorldInterface;\n  callFn: CallFn;\n  caller: CallerInfo;\n  now: Date;\n  genId: () => string;\n}\n\nexport function createActionContext(opts: ActionContextOptions): ActionContext {\n  const frozenNow = opts.now.toISOString();\n  return {\n    world: opts.world,\n    call: opts.callFn,\n    now: () => frozenNow,\n    id: { gen: opts.genId },\n    caller: opts.caller,\n    error: (message: string) => new ActionErrorClass(message),\n  };\n}\n\nexport async function loadExecutor(\n  executorPath: string,\n  basePath: string,\n): Promise<ExecutorFunction> {\n  const fullPath = new URL(executorPath, `file://${basePath}/`).pathname;\n  let mod: Record<string, unknown>;\n  try {\n    mod = await import(fullPath);\n  } catch {\n    throw new ActionErrorClass(`Executor not found: ${executorPath}`);\n  }\n  if (typeof mod.default !== \"function\") {\n    throw new ActionErrorClass(\"Executor must have default export\");\n  }\n  return mod.default as ExecutorFunction;\n}\n\nexport async function executeImperative(\n  executor: ExecutorFunction,\n  ctx: ActionContext,\n  input: Record<string, unknown>,\n): Promise<unknown> {\n  try {\n    return await executor(ctx, input);\n  } catch (e) {\n    if (e instanceof ActionErrorClass) {\n      throw e;\n    }\n    throw new Error(`System error in executor: ${(e as Error).message}`);\n  }\n}\n","import { z } from \"zod\";\nimport type { ActionSpec, DomainSpec } from \"./types.js\";\nimport { ActionErrorClass } from \"./types.js\";\n\nexport interface RegistryEntry {\n  name: string;\n  spec: ActionSpec;\n}\n\nexport class ActionRegistry {\n  private actions = new Map<string, ActionSpec>();\n  private _domain = \"\";\n\n  get domain(): string {\n    return this._domain;\n  }\n\n  load(spec: DomainSpec): void {\n    this._domain = spec.domain;\n    this.actions.clear();\n    for (const [name, actionSpec] of Object.entries(spec.actions)) {\n      this.actions.set(name, actionSpec);\n    }\n  }\n\n  get(name: string): ActionSpec {\n    const spec = this.actions.get(name);\n    if (!spec) {\n      throw new ActionErrorClass(`Unknown action: ${name}`);\n    }\n    return spec;\n  }\n\n  list(): RegistryEntry[] {\n    return [...this.actions.entries()].map(([name, spec]) => ({ name, spec }));\n  }\n}\n\n/**\n * Build a Zod validator from ActionSpec.input and validate the given input.\n * Optional fields (type ending with \"?\") become z.string().optional().\n * Strict mode: extra fields are rejected.\n */\nexport function validateInput(spec: ActionSpec, input: unknown): Record<string, unknown> {\n  const shape: Record<string, z.ZodTypeAny> = {};\n\n  for (const [field, typeStr] of Object.entries(spec.input)) {\n    const isOptional = typeStr.endsWith(\"?\");\n    const baseSchema = z.string();\n    shape[field] = isOptional ? baseSchema.optional() : baseSchema;\n  }\n\n  const schema = z.object(shape).strict();\n  return schema.parse(input);\n}\n","import { compileExecutionPlan, executeAutoPlan, resolveAutoFields } from \"./autogen.js\";\nimport type { CallerInfo } from \"./constraints.js\";\nimport { checkConstraints } from \"./constraints.js\";\nimport type { WorldInterface } from \"./effects.js\";\nimport { createCallProxy, createWorldProxy } from \"./effects.js\";\nimport type { ExecutorFunction } from \"./executor.js\";\nimport { createActionContext, executeImperative, loadExecutor } from \"./executor.js\";\nimport { ActionRegistry, validateInput } from \"./registry.js\";\nimport type { DomainSpec } from \"./types.js\";\n\nexport interface DomainExecutorOptions {\n  spec: DomainSpec;\n  world: WorldInterface;\n  executorsBase: string;\n  genId: () => string;\n  callFn?: (provider: string, args: unknown) => Promise<unknown>;\n}\n\nexport interface ExecInput {\n  input: Record<string, unknown>;\n  caller: CallerInfo;\n}\n\nexport type DomainExecutorFn = (actionName: string, opts: ExecInput) => Promise<unknown>;\n\nexport function createDomainExecutor(options: DomainExecutorOptions): DomainExecutorFn {\n  const registry = new ActionRegistry();\n  registry.load(options.spec);\n\n  const executorCache = new Map<string, ExecutorFunction>();\n  const defaultCallFn =\n    options.callFn ??\n    (async () => {\n      throw new Error(\"No call provider configured\");\n    });\n\n  return async (actionName: string, opts: ExecInput): Promise<unknown> => {\n    // Built-in: list-actions\n    if (actionName === \"list-actions\") {\n      return registry.list().map((e) => ({\n        name: e.name,\n        description: e.spec.description,\n        level: e.spec.level,\n      }));\n    }\n\n    // 1. Lookup\n    const spec = registry.get(actionName);\n\n    // 2. Constraints\n    if (spec.constraints) {\n      checkConstraints(spec.constraints, opts.caller);\n    }\n\n    // 3. Input validation\n    const validatedInput = validateInput(spec, opts.input);\n\n    // 4. Build proxies\n    const worldProxy = createWorldProxy(options.world, spec.effects);\n    const callProxy = createCallProxy(defaultCallFn, spec.effects);\n    const now = new Date();\n\n    // 5. Dispatch: declarative (auto-gen) or imperative (TS executor)\n    if (spec.executor) {\n      // Imperative: load and execute TS executor\n      let executor = executorCache.get(spec.executor);\n      if (!executor) {\n        executor = await loadExecutor(spec.executor, options.executorsBase);\n        executorCache.set(spec.executor, executor);\n      }\n      const ctx = createActionContext({\n        world: worldProxy,\n        callFn: callProxy,\n        caller: opts.caller,\n        now,\n        genId: options.genId,\n      });\n      return executeImperative(executor, ctx, validatedInput);\n    }\n\n    // Declarative: auto-generate execution plan\n    const plan = compileExecutionPlan(spec);\n    const resolvedInput = resolveAutoFields(spec.auto, validatedInput, {\n      did: opts.caller.did ?? \"\",\n      now,\n    });\n    return executeAutoPlan(plan, {\n      world: worldProxy,\n      input: resolvedInput,\n      caller: { did: opts.caller.did ?? \"\", now },\n      genId: options.genId,\n      auto: spec.auto,\n    });\n  };\n}\n","import { parse as parseYaml } from \"yaml\";\n\nimport { type DomainSpec, DomainSpecSchema } from \"./types.js\";\n\n/**\n * Parse a YAML string containing domain action specs into a validated DomainSpec.\n */\nexport function parseDomainSpec(yamlContent: string): DomainSpec {\n  const raw = parseYaml(yamlContent);\n  return DomainSpecSchema.parse(raw);\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@aigne/afs-domain-action",
+  "version": "1.11.0-beta.6",
+  "description": "Domain Action Provider for AFS - program-scoped write model with DSL command spec and constrained TS executors",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Arcblock <blocklet@arcblock.io> https://github.com/arcblock",
+  "homepage": "https://github.com/arcblock/afs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/arcblock/afs"
+  },
+  "bugs": {
+    "url": "https://github.com/arcblock/afs/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
+    },
+    "./*": "./*"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "yaml": "^2.8.2",
+    "zod": "^3.25.67",
+    "@aigne/afs": "1.11.0-beta.6"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.6",
+    "npm-run-all": "^4.1.5",
+    "rimraf": "^6.1.2",
+    "tsdown": "0.20.0-beta.3",
+    "typescript": "5.9.2",
+    "@aigne/typescript-config": "0.0.0",
+    "@aigne/scripts": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "check-types": "tsc --noEmit",
+    "clean": "rimraf dist coverage",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage --coverage-reporter=lcov --coverage-reporter=text"
+  }
+}