effect 4.0.0-beta.20 → 4.0.0-beta.22

package/src/unstable/httpapi/HttpApiClient.ts

@@ -120,6 +120,44 @@ export declare namespace Client {
       never
 }
 
+type ApiGroups<Api extends HttpApi.Any> = Api extends HttpApi.HttpApi<infer _ApiId, infer Groups> ? Groups : never
+
+type EndpointId<Endpoint extends HttpApiEndpoint.Any> = Endpoint extends {
+  readonly method: infer Method extends HttpMethod.HttpMethod
+  readonly path: infer Path extends string
+} ? `${Method} ${Path}`
+  : never
+
+type EndpointWithId<Endpoints extends HttpApiEndpoint.Any, Id extends string> = Id extends
+  `${infer Method extends HttpMethod.HttpMethod} ${infer Path extends string}` ?
+  Extract<Endpoints, { readonly method: Method; readonly path: Path }> :
+  never
+
+type UrlBuilderRequest<Endpoint extends HttpApiEndpoint.Any> = (
+  & ([HttpApiEndpoint.Params<Endpoint>["Encoded"]] extends [never] ? {}
+    : { readonly params: HttpApiEndpoint.Params<Endpoint>["Encoded"] })
+  & ([HttpApiEndpoint.Query<Endpoint>["Encoded"]] extends [never] ? {}
+    : { readonly query: HttpApiEndpoint.Query<Endpoint>["Encoded"] })
+) extends infer Request ? keyof Request extends never ? void | undefined : Request
+  : never
+
+type UrlBuilderArgs<Endpoint extends HttpApiEndpoint.Any> = [UrlBuilderRequest<Endpoint>] extends [void | undefined] ?
+  [request?: UrlBuilderRequest<Endpoint>]
+  : [request: UrlBuilderRequest<Endpoint>]
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export type UrlBuilder<Api extends HttpApi.Any> = <
+  const GroupName extends HttpApiGroup.Name<ApiGroups<Api>>,
+  const Id extends EndpointId<HttpApiGroup.EndpointsWithName<ApiGroups<Api>, GroupName>>
+>(
+  group: GroupName,
+  endpoint: Id,
+  ...args: UrlBuilderArgs<EndpointWithId<HttpApiGroup.EndpointsWithName<ApiGroups<Api>, GroupName>, Id>>
+) => string
+
 const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>(
   api: HttpApi.HttpApi<ApiId, Groups>,
   options: {
@@ -438,6 +476,49 @@ export const endpoint = <
   }).pipe(Effect.map(() => client)) as any
 }
 
+/**
+ * Creates a type-safe URL builder keyed by `${method} ${path}`.
+ *
+ * @example
+ * ```ts
+ * import { Schema } from "effect"
+ * import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi"
+ *
+ * const Api = HttpApi.make("Api").add(
+ *   HttpApiGroup.make("users").add(
+ *     HttpApiEndpoint.get("getUser", "/users/:id", {
+ *       params: { id: Schema.String }
+ *     })
+ *   )
+ * )
+ *
+ * const buildUrl = HttpApiClient.urlBuilder<typeof Api>({
+ *   baseUrl: "https://api.example.com"
+ * })
+ *
+ * buildUrl("users", "GET /users/:id", {
+ *   params: { id: "123" }
+ * })
+ * //=> "https://api.example.com/users/123"
+ * ```
+ * @since 4.0.0
+ * @category constructors
+ */
+export const urlBuilder = <Api extends HttpApi.Any>(options?: {
+  readonly baseUrl?: URL | string | undefined
+}): UrlBuilder<Api> => {
+  return ((_: string, endpoint: string, request?: {
+    readonly params?: Record<string, string | undefined> | undefined
+    readonly query?: UrlParams.Input | undefined
+  }) => {
+    const path = endpoint.slice(endpoint.indexOf(" ") + 1)
+    const withParams = request?.params === undefined ? path : compilePath(path)(request.params)
+    const query = request?.query === undefined ? "" : UrlParams.toString(UrlParams.fromInput(request.query))
+    const url = query === "" ? withParams : `${withParams}?${query}`
+    return options?.baseUrl === undefined ? url : new URL(url, options.baseUrl.toString()).toString()
+  }) as UrlBuilder<Api>
+}
+
 // ----------------------------------------------------------------------------
 
 const paramsRegExp = /:(\w+)\??/g
@@ -448,7 +529,7 @@ const compilePath = (path: string) => {
   if (len === 1) {
     return (_: any) => path
   }
-  return (params: Record<string, string>) => {
+  return (params: Record<string, string | undefined>) => {
     let url = segments[0]
     for (let i = 1; i < len; i++) {
       if (i % 2 === 0) {

package/src/unstable/schema/VariantSchema.ts

@@ -17,7 +17,7 @@ import * as Struct_ from "../../Struct.ts"
  * @since 4.0.0
  * @category Type IDs
  */
-export const TypeId = "~effect/unstable/schema/VariantSchema"
+export const TypeId = "~effect/schema/VariantSchema"
 
 const cacheSymbol = Symbol.for(`${TypeId}/cache`)
 
@@ -71,7 +71,7 @@ export declare namespace Struct {
   }
 }
 
-const FieldTypeId = "~effect/unstable/schema/VariantSchema/Field"
+const FieldTypeId = "~effect/schema/VariantSchema/Field"
 
 /**
  * @since 4.0.0
@@ -542,7 +542,7 @@ const Union = <Members extends ReadonlyArray<Struct<any>>, Variants extends Read
   members: Members,
   variants: Variants
 ) => {
-  class VariantUnion extends (Schema.Union(members.filter((member) => Schema.isSchema(member))) as any) {}
+  const VariantUnion = Schema.Union(members.filter((member) => Schema.isSchema(member))) as any
   for (const variant of variants) {
     Object.defineProperty(VariantUnion, variant, {
       value: Schema.Union(members.map((member) => extract(member, variant)))

package/src/unstable/workflow/Workflow.ts

@@ -374,7 +374,11 @@ export const make = <
           return yield* engine.register(self, execute)
         })
       ),
-    executionId: (payload) => makeExecutionId(self.payloadSchema.make(payload)),
+    executionId: (payload) =>
+      Effect.flatMap(
+        Effect.sync(() => self.payloadSchema.makeUnsafe(payload)),
+        makeExecutionId
+      ),
     withCompensation
   }
 

package/src/unstable/workflow/WorkflowEngine.ts

@@ -502,10 +502,14 @@ const defaultRetrySchedule = Schedule.exponential(200, 1.5).pipe(
 )
 
 /**
+ * A in-memory implementation of the WorkflowEngine. This is useful for testing
+ * and local development, but is not suitable for production use as it does not
+ * provide durability guarantees.
+ *
  * @since 4.0.0
  * @category Layers
  */
-export const layer: Layer.Layer<WorkflowEngine> = Layer.effect(WorkflowEngine)(
+export const layerMemory: Layer.Layer<WorkflowEngine> = Layer.effect(WorkflowEngine)(
   Effect.gen(function*() {
     const scope = yield* Effect.scope