effect 4.0.0-beta.42 → 4.0.0-beta.44

package/src/unstable/cli/internal/parser.ts

@@ -50,7 +50,7 @@ export const parseArgs = (
   lexResult: LexResult,
   command: Command.Any,
   commandPath: ReadonlyArray<string> = []
-): Effect.Effect<ParsedTokens, CliError.CliError, Param.Environment> =>
+): Effect.Effect<ParsedTokens, never, Param.Environment> =>
   Effect.gen(function*() {
     const { tokens, trailingOperands: afterEndOfOptions } = lexResult
     const newCommandPath = [...commandPath, command.name]
@@ -161,7 +161,7 @@ type ParseMode =
 type ParseState = {
   readonly flags: FlagAccumulator
   readonly arguments: Array<string>
-  readonly errors: Array<CliError.CliError>
+  readonly errors: Array<CliError.NonShowHelpErrors>
   mode: ParseMode
 }
 
@@ -179,7 +179,7 @@ type LeafResult = {
   readonly _tag: "Leaf"
   readonly flags: Readonly<FlagMap>
   readonly arguments: ReadonlyArray<string>
-  readonly errors: ReadonlyArray<CliError.CliError>
+  readonly errors: ReadonlyArray<CliError.NonShowHelpErrors>
 }
 
 /**
@@ -190,7 +190,7 @@ type SubcommandResult = {
   readonly flags: Readonly<FlagMap>
   readonly sub: Command<string, unknown, unknown, unknown, unknown>
   readonly childTokens: ReadonlyArray<Token>
-  readonly errors: ReadonlyArray<CliError.CliError>
+  readonly errors: ReadonlyArray<CliError.NonShowHelpErrors>
 }
 
 type LevelResult = LeafResult | SubcommandResult
@@ -317,11 +317,70 @@ const createFlagAccumulator = (params: ReadonlyArray<FlagParam>): FlagAccumulato
 /* ========================================================================== */
 
 type FlagToken = Extract<Token, { _tag: "LongOption" | "ShortOption" }>
+type ResolvedFlag = {
+  readonly param: FlagParam
+  readonly negated: boolean
+}
+type ConsumedFlagValue =
+  | {
+    readonly _tag: "Value"
+    readonly value: string | undefined
+  }
+  | {
+    readonly _tag: "Error"
+    readonly error: CliError.InvalidValue
+  }
 
 const isFlagToken = (t: Token): t is FlagToken => t._tag === "LongOption" || t._tag === "ShortOption"
 
 const getFlagName = (t: FlagToken): string => t._tag === "LongOption" ? t.name : t.flag
 
+const resolveFlag = (
+  token: FlagToken,
+  registry: FlagRegistry
+): ResolvedFlag | undefined => {
+  const tokenName = getFlagName(token)
+  const direct = registry.index.get(tokenName)
+  if (direct && direct.name === tokenName) {
+    return {
+      param: direct,
+      negated: false
+    }
+  }
+
+  if (token._tag === "LongOption" && token.name.startsWith("no-")) {
+    const canonicalName = token.name.slice(3)
+    const param = registry.index.get(canonicalName)
+    if (param && param.name === canonicalName && Primitive.isBoolean(param.primitiveType)) {
+      return {
+        param,
+        negated: true
+      }
+    }
+  }
+
+  if (direct) {
+    return {
+      param: direct,
+      negated: false
+    }
+  }
+
+  return undefined
+}
+
+const invalidNegatedFlagValue = (
+  token: FlagToken,
+  spec: FlagParam,
+  value: string
+): CliError.InvalidValue =>
+  new CliError.InvalidValue({
+    option: spec.name,
+    value,
+    expected: `omit the value and use ${token.raw} by itself to set --${spec.name} to false`,
+    kind: "flag"
+  })
+
 /**
  * Checks if a token is a boolean literal value.
  * Recognizes: true/false, yes/no, on/off, 1/0
@@ -346,28 +405,64 @@ const asBooleanLiteral = (token: Token | undefined): string | undefined =>
 const consumeFlagValue = (
   cursor: TokenCursor,
   token: FlagToken,
-  spec: FlagParam
-): string | undefined => {
+  spec: FlagParam,
+  negated = false
+): ConsumedFlagValue => {
   // Inline value has highest priority
+  if (negated) {
+    if (token.value !== undefined) {
+      return {
+        _tag: "Error",
+        error: invalidNegatedFlagValue(token, spec, token.value)
+      }
+    }
+
+    const literal = asBooleanLiteral(cursor.peek())
+    if (literal !== undefined) {
+      cursor.take()
+      return {
+        _tag: "Error",
+        error: invalidNegatedFlagValue(token, spec, literal)
+      }
+    }
+
+    return {
+      _tag: "Value",
+      value: "false"
+    }
+  }
+
   if (token.value !== undefined) {
-    return token.value
+    return {
+      _tag: "Value",
+      value: token.value
+    }
   }
 
   // Boolean flags: check for explicit literal or default to "true"
   if (Primitive.isBoolean(spec.primitiveType)) {
     const literal = asBooleanLiteral(cursor.peek())
     if (literal !== undefined) cursor.take()
-    return literal ?? "true"
+    return {
+      _tag: "Value",
+      value: literal ?? "true"
+    }
   }
 
   // Non-boolean: try to consume next Value token
   const next = cursor.peek()
   if (next?._tag === "Value") {
     cursor.take()
-    return next.value
+    return {
+      _tag: "Value",
+      value: next.value
+    }
   }
 
-  return undefined
+  return {
+    _tag: "Value",
+    value: undefined
+  }
 }
 
 /**
@@ -379,9 +474,10 @@ const consumeFlagValue = (
 export const consumeKnownFlags = (
   tokens: ReadonlyArray<Token>,
   registry: FlagRegistry
-): { flagMap: FlagMap; remainder: ReadonlyArray<Token> } => {
+): { flagMap: FlagMap; remainder: ReadonlyArray<Token>; errors: ReadonlyArray<CliError.InvalidValue> } => {
   const flagMap = createEmptyFlagMap(registry.params)
   const remainder: Array<Token> = []
+  const errors: Array<CliError.InvalidValue> = []
   const cursor = makeCursor(tokens)
 
   for (let t = cursor.take(); t; t = cursor.take()) {
@@ -390,19 +486,23 @@ export const consumeKnownFlags = (
       continue
     }
 
-    const param = registry.index.get(getFlagName(t))
-    if (!param) {
+    const resolved = resolveFlag(t, registry)
+    if (!resolved) {
       remainder.push(t)
       continue
     }
 
-    const value = consumeFlagValue(cursor, t, param)
-    if (value !== undefined) {
-      flagMap[param.name].push(value)
+    const consumed = consumeFlagValue(cursor, t, resolved.param, resolved.negated)
+    if (consumed._tag === "Error") {
+      errors.push(consumed.error)
+      continue
+    }
+    if (consumed.value !== undefined) {
+      flagMap[resolved.param.name].push(consumed.value)
     }
   }
 
-  return { flagMap, remainder }
+  return { flagMap, remainder, errors }
 }
 
 /* ========================================================================== */
@@ -419,6 +519,9 @@ const createUnrecognizedFlagError = (
 
   for (const p of params) {
     validNames.push(p.name)
+    if (Primitive.isBoolean(p.primitiveType)) {
+      validNames.push(`no-${p.name}`)
+    }
     for (const alias of p.aliases) {
       validNames.push(alias)
     }
@@ -498,6 +601,7 @@ const resolveFirstValue = (
     // npm-style: inherited parent flags can appear after subcommand name
     const tail = consumeKnownFlags(cursor.rest(), inheritedFlagRegistry)
     state.flags.merge(tail.flagMap)
+    state.errors.push(...tail.errors)
 
     return {
       _tag: "Subcommand",
@@ -542,15 +646,20 @@ const processFlag = (
   state: ParseState
 ): void => {
   const { commandPath, flagRegistry } = context
-  const name = getFlagName(token)
-  const spec = flagRegistry.index.get(name)
+  const resolved = resolveFlag(token, flagRegistry)
 
-  if (!spec) {
+  if (!resolved) {
     state.errors.push(createUnrecognizedFlagError(token, flagRegistry.params, commandPath))
     return
   }
 
-  state.flags.add(spec.name, consumeFlagValue(cursor, token, spec))
+  const consumed = consumeFlagValue(cursor, token, resolved.param, resolved.negated)
+  if (consumed._tag === "Error") {
+    state.errors.push(consumed.error)
+    return
+  }
+
+  state.flags.add(resolved.param.name, consumed.value)
 }
 
 /**

package/src/unstable/cluster/ClusterSchema.ts

@@ -1,8 +1,8 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import { constFalse, constTrue, identity } from "../../Function.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Rpc from "../rpc/Rpc.ts"
 import type { EntityId } from "./EntityId.ts"
 import type { Request } from "./Envelope.ts"
@@ -11,7 +11,7 @@ import type { Request } from "./Envelope.ts"
  * @since 4.0.0
  * @category Annotations
  */
-export const Persisted = ServiceMap.Reference<boolean>("effect/cluster/ClusterSchema/Persisted", {
+export const Persisted = Context.Reference<boolean>("effect/cluster/ClusterSchema/Persisted", {
   defaultValue: constFalse
 })
 
@@ -22,7 +22,7 @@ export const Persisted = ServiceMap.Reference<boolean>("effect/cluster/ClusterSc
  * @since 4.0.0
  * @category Annotations
  */
-export const WithTransaction = ServiceMap.Reference<boolean>(
+export const WithTransaction = Context.Reference<boolean>(
   "effect/cluster/ClusterSchema/WithTransaction",
   { defaultValue: constFalse }
 )
@@ -31,7 +31,7 @@ export const WithTransaction = ServiceMap.Reference<boolean>(
  * @since 4.0.0
  * @category Annotations
  */
-export const Uninterruptible = ServiceMap.Reference<boolean | "client" | "server">(
+export const Uninterruptible = Context.Reference<boolean | "client" | "server">(
   "effect/cluster/ClusterSchema/Uninterruptible",
   { defaultValue: constFalse }
 )
@@ -40,8 +40,8 @@ export const Uninterruptible = ServiceMap.Reference<boolean | "client" | "server
  * @since 4.0.0
  * @category Annotations
  */
-export const isUninterruptibleForServer = (context: ServiceMap.ServiceMap<never>): boolean => {
-  const value = ServiceMap.get(context, Uninterruptible)
+export const isUninterruptibleForServer = (context: Context.Context<never>): boolean => {
+  const value = Context.get(context, Uninterruptible)
   return value === true || value === "server"
 }
 
@@ -49,8 +49,8 @@ export const isUninterruptibleForServer = (context: ServiceMap.ServiceMap<never>
  * @since 4.0.0
  * @category Annotations
  */
-export const isUninterruptibleForClient = (context: ServiceMap.ServiceMap<never>): boolean => {
-  const value = ServiceMap.get(context, Uninterruptible)
+export const isUninterruptibleForClient = (context: Context.Context<never>): boolean => {
+  const value = Context.get(context, Uninterruptible)
   return value === true || value === "client"
 }
 
@@ -58,7 +58,7 @@ export const isUninterruptibleForClient = (context: ServiceMap.ServiceMap<never>
  * @since 4.0.0
  * @category Annotations
  */
-export const ShardGroup = ServiceMap.Reference<(entityId: EntityId) => string>(
+export const ShardGroup = Context.Reference<(entityId: EntityId) => string>(
   "effect/cluster/ClusterSchema/ShardGroup",
   { defaultValue: () => (_) => "default" }
 )
@@ -67,7 +67,7 @@ export const ShardGroup = ServiceMap.Reference<(entityId: EntityId) => string>(
  * @since 4.0.0
  * @category Annotations
  */
-export const ClientTracingEnabled = ServiceMap.Reference<boolean>("effect/cluster/ClusterSchema/ClientTracingEnabled", {
+export const ClientTracingEnabled = Context.Reference<boolean>("effect/cluster/ClusterSchema/ClientTracingEnabled", {
   defaultValue: constTrue
 })
 
@@ -78,8 +78,8 @@ export const ClientTracingEnabled = ServiceMap.Reference<boolean>("effect/cluste
  * @since 4.0.0
  * @category Annotations
  */
-export const Dynamic = ServiceMap.Reference<
-  (annotations: ServiceMap.ServiceMap<never>, request: Request<Rpc.AnyWithProps>) => ServiceMap.ServiceMap<never>
+export const Dynamic = Context.Reference<
+  (annotations: Context.Context<never>, request: Request<Rpc.AnyWithProps>) => Context.Context<never>
 >(
   "effect/cluster/ClusterSchema/Dynamic",
   { defaultValue: () => identity }

package/src/unstable/cluster/ClusterWorkflowEngine.ts

@@ -1,12 +1,12 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as DateTime from "../../DateTime.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
-import { constFalse } from "../../Function.ts"
 import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
@@ -16,7 +16,6 @@ import type * as Record from "../../Record.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import type * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Rpc from "../rpc/Rpc.ts"
 import { ClientAbort } from "../rpc/RpcSchema.ts"
 import * as Activity from "../workflow/Activity.ts"
@@ -30,6 +29,8 @@ import * as Entity from "./Entity.ts"
 import * as EntityAddress from "./EntityAddress.ts"
 import * as EntityId from "./EntityId.ts"
 import * as EntityType from "./EntityType.ts"
+import * as Envelope from "./Envelope.ts"
+import * as Message from "./Message.ts"
 import { MessageStorage } from "./MessageStorage.ts"
 import type { WithExitEncoded } from "./Reply.ts"
 import * as Reply from "./Reply.ts"
@@ -108,7 +109,7 @@ export const make = Effect.gen(function*() {
 
   const activities = new Map<string, {
     readonly activity: Activity.Any
-    readonly services: ServiceMap.ServiceMap<any>
+    readonly context: Context.Context<any>
   }>()
   const interruptedActivities = new Set<string>()
   const activityLatches = new Map<string, Latch.Latch>()
@@ -131,22 +132,30 @@ export const make = Effect.gen(function*() {
   })
   const clockClient = yield* ClockEntity.client
 
-  const requestIdFor = Effect.fnUntraced(function*(options: {
+  const entityAddressFor = (options: {
     readonly workflow: Workflow.Any
     readonly entityType: string
     readonly executionId: string
-    readonly tag: string
-    readonly id: string
-  }) {
-    const shardGroup = ServiceMap.get(options.workflow.annotations, ClusterSchema.ShardGroup)(
+  }) => {
+    const shardGroup = Context.get(options.workflow.annotations, ClusterSchema.ShardGroup)(
       options.executionId as EntityId.EntityId
     )
     const entityId = EntityId.make(options.executionId)
-    const address = EntityAddress.make({
+    return EntityAddress.make({
       entityType: EntityType.make(options.entityType),
       entityId,
       shardId: sharding.getShardId(entityId, shardGroup)
     })
+  }
+
+  const requestIdFor = Effect.fnUntraced(function*(options: {
+    readonly workflow: Workflow.Any
+    readonly entityType: string
+    readonly executionId: string
+    readonly tag: string
+    readonly id: string
+  }) {
+    const address = entityAddressFor(options)
     return yield* storage.requestIdForPrimaryKey({ address, tag: options.tag, id: options.id })
   })
 
@@ -201,7 +210,7 @@ export const make = Effect.gen(function*() {
     readonly workflow: Workflow.Any
     readonly executionId: string
   }) {
-    const shardGroup = ServiceMap.get(options.workflow.annotations, ClusterSchema.ShardGroup)(
+    const shardGroup = Context.get(options.workflow.annotations, ClusterSchema.ShardGroup)(
       options.executionId as EntityId.EntityId
     )
     const entityId = EntityId.make(options.executionId)
@@ -253,6 +262,46 @@ export const make = Effect.gen(function*() {
     yield* sharding.reset(requestId.value)
   }, Effect.scoped)
 
+  const interrupt = Effect.fnUntraced(
+    function*(workflow: Workflow.Any, executionId: string) {
+      ensureEntity(workflow)
+      const requestId = yield* requestIdFor({
+        workflow,
+        entityType: `Workflow/${workflow.name}`,
+        executionId,
+        tag: "run",
+        id: ""
+      })
+      if (Option.isNone(requestId)) {
+        return Option.none()
+      }
+      const reply = yield* replyForRequestId(requestId.value)
+
+      const nonSuspendedReply = Option.filter(
+        reply,
+        (reply) => reply.exit._tag !== "Success" || reply.exit.value._tag !== "Suspended"
+      )
+      if (Option.isSome(nonSuspendedReply)) {
+        return Option.none()
+      }
+
+      yield* engine.deferredDone(InterruptSignal, {
+        workflowName: workflow.name,
+        executionId,
+        deferredName: InterruptSignal.name,
+        exit: Exit.void
+      })
+
+      return requestId
+    },
+    Effect.retry({
+      while: (e) => e._tag === "PersistenceError",
+      times: 3,
+      schedule: Schedule.exponential(250)
+    }),
+    Effect.orDie
+  )
+
   const engine = WorkflowEngine.makeUnsafe({
     register: (workflow, execute) =>
       Effect.suspend(() =>
@@ -269,9 +318,9 @@ export const make = Effect.gen(function*() {
                 if (payload[payloadParentKey]) {
                   parent = payload[payloadParentKey]
                 }
-                return execute(workflow.payloadSchema.makeUnsafe(payload) as object, executionId).pipe(
+                return execute(workflow.payloadSchema.make(payload) as object, executionId).pipe(
                   Effect.onExit((exit) => {
-                    const suspendOnFailure = ServiceMap.get(workflow.annotations, Workflow.SuspendOnFailure)
+                    const suspendOnFailure = Context.get(workflow.annotations, Workflow.SuspendOnFailure)
                     if (!instance.suspended && !(suspendOnFailure && exit._tag === "Failure")) {
                       return parent ? ensureSuccess(sendResumeParent(parent)) : Effect.void
                     }
@@ -308,11 +357,11 @@ export const make = Effect.gen(function*() {
                     yield* latch.await
                     entry = activities.get(activityId)
                   }
-                  const contextMap = new Map(entry.services.mapUnsafe)
+                  const contextMap = new Map(entry.context.mapUnsafe)
                   contextMap.set(Activity.CurrentAttempt.key, payload.attempt)
                   contextMap.set(WorkflowEngine.WorkflowInstance.key, instance)
                   return yield* entry.activity.executeEncoded.pipe(
-                    Effect.provideServices(ServiceMap.makeUnsafe(contextMap))
+                    Effect.provideContext(Context.makeUnsafe(contextMap))
                   )
                 }).pipe(
                   Workflow.intoResult,
@@ -386,52 +435,41 @@ export const make = Effect.gen(function*() {
       return Option.some(yield* exit)
     }, Effect.orDie),
 
-    interrupt: Effect.fnUntraced(
-      function*(workflow, executionId) {
-        ensureEntity(workflow)
-        const reply = yield* requestReply({
-          workflow,
-          entityType: `Workflow/${workflow.name}`,
-          executionId,
-          tag: "run",
-          id: ""
-        })
-
-        const nonSuspendedReply = Option.filter(
-          reply,
-          (reply) => reply.exit._tag !== "Success" || reply.exit.value._tag !== "Suspended"
-        )
-        if (Option.isSome(nonSuspendedReply)) {
-          return
-        }
-
-        yield* engine.deferredDone(InterruptSignal, {
-          workflowName: workflow.name,
-          executionId,
-          deferredName: InterruptSignal.name,
-          exit: Exit.void
-        })
-      },
-      Effect.retry({
-        while: (e) => e._tag === "PersistenceError",
-        times: 3,
-        schedule: Schedule.exponential(250)
-      }),
-      Effect.orDie
-    ),
+    interrupt: (workflow, executionId) => Effect.asVoid(interrupt(workflow, executionId)),
+    interruptUnsafe: Effect.fnUntraced(function*(workflow, executionId) {
+      const requestId = yield* interrupt(workflow, executionId)
+      if (Option.isNone(requestId)) return
+      const entity = ensureEntity(workflow)
+      const runRpc = entity.protocol.requests.get("run")!
+      yield* Effect.orDie(sharding.sendOutgoing(
+        new Message.OutgoingEnvelope({
+          rpc: runRpc,
+          envelope: new Envelope.Interrupt({
+            id: yield* sharding.getSnowflake,
+            address: entityAddressFor({
+              workflow,
+              entityType: `Workflow/${workflow.name}`,
+              executionId
+            }),
+            requestId: requestId.value
+          })
+        }),
+        false
+      ))
+    }),
 
     resume: (workflow, executionId) => ensureSuccess(resume(workflow, executionId)),
 
     activityExecute: Effect.fnUntraced(
       function*(activity, attempt) {
-        const services = yield* Effect.services<WorkflowEngine.WorkflowInstance>()
-        const instance = ServiceMap.get(services, WorkflowEngine.WorkflowInstance)
+        const services = yield* Effect.context<WorkflowEngine.WorkflowInstance>()
+        const instance = Context.get(services, WorkflowEngine.WorkflowInstance)
         yield* Effect.annotateCurrentSpan("executionId", instance.executionId)
         const activityId = `${instance.executionId}/${activity.name}`
         const client = (yield* RcMap.get(clientsPartial, instance.workflow.name))(instance.executionId)
         while (true) {
           if (!activities.has(activityId)) {
-            activities.set(activityId, { activity, services })
+            activities.set(activityId, { activity, context: services })
             const latch = activityLatches.get(activityId)
             if (latch) {
               yield* latch.release
@@ -442,7 +480,7 @@ export const make = Effect.gen(function*() {
             client.activity({
               name: activity.name,
               attempt,
-              withTransaction: ServiceMap.get(activity.annotations, ClusterSchema.WithTransaction)
+              withTransaction: Context.get(activity.annotations, ClusterSchema.WithTransaction)
             })
           )
           // If the activity has suspended and did not execute, we need to resume
@@ -543,7 +581,7 @@ const ActivityRpc = Rpc.make("activity", {
     name: Schema.String,
     attempt: Schema.Number,
     withTransaction: Schema.Boolean.pipe(
-      Schema.withDecodingDefault(constFalse)
+      Schema.withDecodingDefault(Effect.succeed(false))
     )
   },
   primaryKey: ({ attempt, name }) => activityPrimaryKey(name, attempt),
@@ -557,7 +595,7 @@ const ActivityRpc = Rpc.make("activity", {
     ClusterSchema.Dynamic,
     (annotations, request) =>
       (request.payload as any).withTransaction
-        ? ServiceMap.add(annotations, ClusterSchema.WithTransaction, true)
+        ? Context.add(annotations, ClusterSchema.WithTransaction, true)
         : annotations
   )