effect-app 4.0.0-beta.248 → 4.0.0-beta.249

package/src/Store.ts

@@ -0,0 +1,243 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type * as Redacted from "effect/Redacted"
+import * as Semaphore from "effect/Semaphore"
+import type { NonEmptyReadonlyArray } from "./Array.js"
+import type { OptimisticConcurrencyException } from "./client/errors.js"
+import * as Context from "./Context.js"
+import * as Effect from "./Effect.js"
+import type { FilterResult } from "./Model/filter/filterApi.js"
+import type { FieldValues } from "./Model/filter/types.js"
+import type { FieldPath } from "./Model/filter/types/path/index.js"
+import type { AggregateIrExpression, ComputedProjectionIrExpression, RawQuery } from "./Model/query.js"
+import type * as Option from "./Option.js"
+
+/**
+ * Adapter-neutral unique-key definition for stores that support unique indexes,
+ * such as the Cosmos adapter. This shape is intentionally kept structurally
+ * compatible with adapter-specific `UniqueKey` types. Each path identifies a
+ * field participating in the unique key, and adapters forward these paths
+ * directly to the underlying storage engine.
+ */
+export interface UniqueKey {
+  readonly paths: string[]
+}
+
+export interface StoreConfig<E> {
+  partitionValue: (e?: E) => string
+  /**
+   * Primarily used for testing, creating namespaces in the database to separate data e.g to run multiple tests in isolation within the same database.
+   * Memory/Disk use separate store instances per namespace. CosmosDB uses namespace-prefixed partition keys. SQL uses a `_namespace` column.
+   */
+  allowNamespace?: (namespace: string) => boolean
+  /**
+   * just in time migrations, supported by the database driver, supporting queries, for simple default values
+   */
+  defaultValues?: Partial<E>
+
+  /**
+   * How many items can be processed in one batch at a time.
+   * Defaults to 100 for CosmosDB.
+   */
+  maxBulkSize?: number
+
+  /**
+   * Unique indexes, mainly for CosmosDB
+   */
+  uniqueKeys?: UniqueKey[]
+}
+
+export type SupportedValues = string | boolean | number | null
+export type SupportedValues2 = string | boolean | number
+
+// default is eq
+export type Where =
+  | { key: string; t?: "eq" | "not-eq"; value: SupportedValues }
+  | { key: string; t: "gt" | "lt" | "gte" | "lte"; value: SupportedValues2 }
+  | {
+    key: string
+    t: "contains" | "starts-with" | "ends-with" | "not-contains" | "not-starts-with" | "not-ends-with"
+    value: string
+  }
+  | { key: string; t: "includes" | "not-includes"; value: string }
+  | {
+    key: string
+    t: "in" | "not-in"
+    value: readonly (SupportedValues)[]
+  }
+
+export type Filter = readonly FilterResult[]
+
+export interface O<TFieldValues extends FieldValues> {
+  key: FieldPath<TFieldValues>
+  direction: "ASC" | "DESC"
+}
+
+export interface FilterArgs<Encoded extends FieldValues, U extends keyof Encoded = never> {
+  t: Encoded
+  filter?: Filter | undefined
+  select?:
+    | NonEmptyReadonlyArray<
+      U | { key: string; subKeys: readonly string[] } | {
+        key: string
+        computed: ComputedProjectionIrExpression
+      } | {
+        key: string
+        path: string
+      } | {
+        key: string
+        aggregate: AggregateIrExpression
+      }
+    >
+    | undefined
+  order?: NonEmptyReadonlyArray<O<NoInfer<Encoded>>>
+  limit?: number | undefined
+  skip?: number | undefined
+}
+
+export type FilterFunc<Encoded extends FieldValues> = <U extends keyof Encoded = never>(
+  args: FilterArgs<Encoded, U>
+) => Effect.Effect<(U extends undefined ? Encoded : Pick<Encoded, U>)[]>
+
+export interface Store<
+  IdKey extends keyof Encoded,
+  Encoded extends FieldValues,
+  PM extends PersistenceModelType<Encoded> = PersistenceModelType<Encoded>
+> {
+  all: Effect.Effect<PM[]>
+  filter: FilterFunc<Encoded>
+  find: (id: Encoded[IdKey]) => Effect.Effect<Option.Option<PM>>
+  set: (e: PM) => Effect.Effect<PM, OptimisticConcurrencyException>
+  batchSet: (
+    items: NonEmptyReadonlyArray<PM>
+  ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException>
+  bulkSet: (
+    items: NonEmptyReadonlyArray<PM>
+  ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException>
+  batchRemove: (ids: NonEmptyReadonlyArray<Encoded[IdKey]>, partitionKey?: string) => Effect.Effect<void>
+  queryRaw: <Out>(query: RawQuery<Encoded, Out>) => Effect.Effect<readonly Out[]>
+  /**
+   * Explicitly seed a namespace. Primary is seeded eagerly on initialization.
+   * Non-primary namespaces must be seeded explicitly before use.
+   */
+  seedNamespace: (namespace: string) => Effect.Effect<void>
+}
+
+export class StoreMaker extends Context.Opaque<StoreMaker, {
+  make: <IdKey extends keyof Encoded, Encoded extends FieldValues, R = never, E = never>(
+    name: string,
+    idKey: IdKey,
+    seed?: Effect.Effect<Iterable<Encoded>, E, R>,
+    config?: StoreConfig<Encoded>
+  ) => Effect.Effect<Store<IdKey, Encoded>, E, R>
+}>()("effect-app/StoreMaker") {
+}
+
+export const makeContextMap = () => {
+  const etags = new Map<string, string>()
+  const getEtag = (id: string) => etags.get(id)
+  const setEtag = (id: string, eTag: string | undefined) => {
+    if (eTag === undefined) {
+      etags.delete(id)
+    } else {
+      etags.set(id, eTag)
+    }
+  }
+
+  // const parsedCache = new Map<
+  //   Parser<any, any, any>,
+  //   Map<unknown, These.These<unknown, unknown>>
+  // >()
+
+  // const parserCache = new Map<
+  //   Parser<any, any, any>,
+  //   (i: any) => These.These<any, any>
+  // >()
+
+  // const setAndReturn = <I, E, A>(
+  //   p: Parser<I, E, A>,
+  //   np: (i: I) => These.These<E, A>
+  // ) => {
+  //   parserCache.set(p, np)
+  //   return np
+  // }
+
+  // const parserEnv: ParserEnv = {
+  //   // TODO: lax: true would turn off refinement checks, may help on large payloads
+  //   // but of course removes confirming of validation rules (which may be okay for a database owned by the app, as we write safely)
+  //   lax: false,
+  //   cache: {
+  //     getOrSetParser: (p) => parserCache.get(p) ?? setAndReturn(p, (i) => parserEnv.cache!.getOrSet(i, p)),
+  //     getOrSetParsers: (parsers) => {
+  //       return Object.entries(parsers).reduce((prev, [k, v]) => {
+  //         prev[k] = parserEnv.cache!.getOrSetParser(v)
+  //         return prev
+  //       }, {} as any)
+  //     },
+  //     getOrSet: (i, parse): any => {
+  //       const c = parsedCache.get(parse)
+  //       if (c) {
+  //         const f = c.get(i)
+  //         if (f) {
+  //           // console.log("$$$ cache hit", i)
+  //           return f
+  //         } else {
+  //           const nf = parse(i, parserEnv)
+  //           c.set(i, nf)
+  //           return nf
+  //         }
+  //       } else {
+  //         const nf = parse(i, parserEnv)
+  //         parsedCache.set(parse, new Map([[i, nf]]))
+  //         return nf
+  //       }
+  //     }
+  //   }
+  // }
+
+  const store = new Map<symbol, unknown>()
+  const sem = Semaphore.makeUnsafe(1)
+
+  return {
+    createdAt: new Date(),
+    get: getEtag,
+    set: setEtag,
+    getOrCreateStore: <T>(key: symbol, make: () => T): T => {
+      let value = store.get(key) as T | undefined
+      if (value === undefined) {
+        value = make()
+        store.set(key, value)
+      }
+      return value
+    },
+    getOrCreateStoreEffect: <T, E, R>(key: symbol, make: Effect.Effect<T, E, R>): Effect.Effect<T, E, R> =>
+      sem.withPermits(1)(Effect.uninterruptible(Effect.gen(function*() {
+        const value = store.get(key) as T | undefined
+        if (value !== undefined) return value
+        const v = yield* make
+        store.set(key, v)
+        return v
+      }))),
+    clear: () => {
+      etags.clear()
+      store.clear()
+    }
+  }
+}
+
+const makeMap = Effect.acquireRelease(
+  Effect.sync(() => makeContextMap()),
+  (m) => Effect.sync(() => m.clear())
+)
+
+export class ContextMap extends Context.Opaque<ContextMap>()("effect-app/ContextMap", { make: makeMap }) {
+}
+
+export type PersistenceModelType<Encoded extends object> = Encoded & {
+  _etag?: string | undefined
+}
+
+export interface StorageConfig {
+  url: Redacted.Redacted
+  prefix: string
+  dbName: string
+}

package/src/index.ts

@@ -10,8 +10,10 @@ export * as ConfigProvider from "./ConfigProvider.js"
 export * as Context from "./Context.js"
 export * as Effect from "./Effect.js"
 export * as Layer from "./Layer.js"
+export * as Model from "./Model.js"
 export * as NonEmptySet from "./NonEmptySet.js"
 export * as Set from "./Set.js"
+export * as Store from "./Store.js"
 
 export { type NonEmptyArray, type NonEmptyReadonlyArray } from "./Array.js"
 

package/src/runtime.ts

@@ -0,0 +1,56 @@
+import * as Exit from "effect/Exit"
+import { flow } from "effect/Function"
+import * as Logger from "effect/Logger"
+import * as ManagedRuntime from "effect/ManagedRuntime"
+import { CauseException } from "./client/errors.js"
+import { type Context } from "./Context.js"
+import * as Effect from "./Effect.js"
+import * as Layer from "./Layer.js"
+
+export const makeAppRuntime = Effect.fnUntraced(function*<A, E>(layer: Layer.Layer<A, E>) {
+  const l = layer.pipe(
+    Layer.provide(Logger.layer([Logger.consolePretty()]))
+  ) as Layer.Layer<A>
+  const mrt = ManagedRuntime.make(l)
+  yield* mrt.contextEffect
+  return Object.assign(mrt, {
+    [Symbol.dispose]() {
+      return Effect.runSync(mrt.disposeEffect)
+    },
+
+    [Symbol.asyncDispose]() {
+      return mrt.dispose()
+    }
+  }) // as we initialise here, there is no more error left.
+})
+
+export function initializeSync<A, E>(layer: Layer.Layer<A, E>) {
+  const runtime = Effect.runSync(makeAppRuntime(layer))
+  return runtime
+}
+
+export function initializeAsync<A, E>(layer: Layer.Layer<A, E>) {
+  return Effect
+    .runPromise(makeAppRuntime(layer))
+}
+
+// we wrap into CauseException because we want to keep the full cause of the failure.
+export const makeRunPromise = <T>(services: Context<T>) =>
+  flow(Effect.runPromiseExitWith(services), (_) =>
+    _.then(
+      Exit.match({
+        onFailure: (cause) => Promise.reject(new CauseException(cause, "runPromise")),
+        onSuccess: (value) => Promise.resolve(value)
+      })
+    ))
+
+export const makeRunSync = <T>(services: Context<T>) =>
+  flow(
+    Effect.runSyncExitWith(services),
+    Exit.match({
+      onFailure: (cause) => {
+        throw new CauseException(cause, "runSync")
+      },
+      onSuccess: (value) => value
+    })
+  )

package/src/toast.ts

@@ -0,0 +1,54 @@
+import * as Context from "./Context.js"
+import { accessEffectFn } from "./Context.js"
+import * as Effect from "./Effect.js"
+import * as Option from "./Option.js"
+
+export type ToastId = string | number
+export type ToastOpts = { id?: ToastId; timeout?: number; groupId?: string; requestId?: string }
+export type ToastOptsInternal = { id?: ToastId | null; timeout?: number; groupId?: string; requestId?: string }
+
+export type UseToast = () => {
+  error: (this: void, message: string, options?: ToastOpts) => ToastId
+  warning: (this: void, message: string, options?: ToastOpts) => ToastId
+  success: (this: void, message: string, options?: ToastOpts) => ToastId
+  info: (this: void, message: string, options?: ToastOpts) => ToastId
+  dismiss: (this: void, id: ToastId) => void
+}
+
+export class CurrentToastId extends Context.Opaque<CurrentToastId, { toastId: ToastId }>()("CurrentToastId") {}
+
+/** fallback to CurrentToastId when available unless id is explicitly set to a value or null */
+export const wrap = (toast: ReturnType<UseToast>) => {
+  const wrap = (toastHandler: (message: string, options?: ToastOpts) => ToastId) => {
+    return (message: string, options?: ToastOptsInternal) =>
+      Effect.serviceOption(CurrentToastId).pipe(
+        Effect.flatMap((currentToast) =>
+          Effect.sync(() => {
+            const { id: _id, ...rest } = options ?? {}
+            const id = _id !== undefined
+              ? _id ?? undefined
+              : Option.getOrUndefined(Option.map(currentToast, (_) => _.toastId))
+            // when id is undefined, we may end up with no toast at all..
+            return toastHandler(message, id !== undefined ? { ...rest, id } : rest)
+          })
+        )
+      )
+  }
+  return {
+    error: wrap(toast.error),
+    info: wrap(toast.info),
+    success: wrap(toast.success),
+    warning: wrap(toast.warning),
+    dismiss: (toastId: ToastId) => Effect.sync(() => toast.dismiss(toastId))
+  }
+}
+
+type ToastShape = ReturnType<typeof wrap>
+
+export class Toast extends Context.Opaque<Toast, ToastShape>()("Toast") {
+  static readonly error = accessEffectFn(this, "error")
+  static readonly info = accessEffectFn(this, "info")
+  static readonly success = accessEffectFn(this, "success")
+  static readonly warning = accessEffectFn(this, "warning")
+  static readonly dismiss = accessEffectFn(this, "dismiss")
+}

package/src/withToast.ts

@@ -0,0 +1,133 @@
+import * as Cause from "effect/Cause"
+import * as Fiber from "effect/Fiber"
+import * as Context from "./Context.js"
+import * as Effect from "./Effect.js"
+import * as Layer from "./Layer.js"
+import type * as Option from "./Option.js"
+import * as S from "./Schema.js"
+import { CurrentToastId, Toast, type ToastId } from "./toast.js"
+import { wrapEffect } from "./utils.js"
+
+export interface ToastOptions<A, E, Args extends ReadonlyArray<unknown>, WaiR, SucR, ErrR> {
+  stableToastId?: undefined | string | ((...args: Args) => string | undefined)
+  timeout?: number
+  showSpanInfo?: false
+  groupId?: string
+  onWaiting:
+    | string
+    | ((...args: Args) => string | null)
+    | null
+    | ((
+      ...args: Args
+    ) => Effect.Effect<string | null, never, WaiR>)
+  onSuccess:
+    | string
+    | ((a: A, ...args: Args) => string | null)
+    | null
+    | ((
+      a: A,
+      ...args: Args
+    ) => Effect.Effect<string | null, never, SucR>)
+  onFailure:
+    | string
+    | ((
+      error: Option.Option<E>,
+      ...args: Args
+    ) => string | { level: "warn" | "error"; message: string })
+    | ((
+      error: Option.Option<E>,
+      ...args: Args
+    ) => Effect.Effect<string | { level: "warn" | "error"; message: string }, never, ErrR>)
+}
+
+// @effect-diagnostics-next-line missingEffectServiceDependency:off
+export class WithToast extends Context.Service<WithToast>()("WithToast", {
+  make: Effect.gen(function*() {
+    const toast = yield* Toast
+    return <A, E, Args extends readonly unknown[], R, WaiR = never, SucR = never, ErrR = never>(
+      options: ToastOptions<A, E, Args, WaiR, SucR, ErrR>
+    ) =>
+      Effect.fnUntraced(function*(self: Effect.Effect<A, E, R>, ...args: Args) {
+        const baseTimeout = options.timeout ?? 3_000
+
+        const stableToastId = typeof options.stableToastId === "function"
+          ? options.stableToastId(...args)
+          : options.stableToastId
+
+        const requestId: string = yield* Effect.currentSpan.pipe(
+          Effect.map((span) => span.traceId),
+          Effect.orElseSucceed(() => S.StringId.make())
+        )
+        const groupId = options.groupId
+        const meta = { ...(groupId !== undefined ? { groupId } : {}), requestId }
+
+        const t = yield* wrapEffect(options.onWaiting)(...args)
+        const toastId: ToastId | undefined = t === null
+          ? stableToastId
+          : stableToastId ?? `wait-${Math.random().toString(36).slice(2)}`
+
+        const waitingFiber = t === null ? undefined : yield* Effect.forkChild(
+          Effect.sleep("1 seconds").pipe(
+            Effect.andThen(toast.info(t, { id: toastId!, timeout: Infinity, ...meta }))
+          )
+        )
+        const interruptWaiting = waitingFiber ? Fiber.interrupt(waitingFiber) : Effect.void
+
+        return yield* self.pipe(
+          Effect.tap(Effect.fnUntraced(function*(a) {
+            yield* interruptWaiting
+            const t = yield* wrapEffect(options.onSuccess)(a, ...args)
+            if (t === null) {
+              return
+            }
+            yield* toast.success(
+              t,
+              toastId !== undefined
+                ? { id: toastId, timeout: baseTimeout, ...meta }
+                : { timeout: baseTimeout, ...meta }
+            )
+          })),
+          Effect.tapCause(Effect.fnUntraced(function*(cause) {
+            yield* interruptWaiting
+            yield* Effect.logDebug(
+              "WithToast - caught error cause: " + Cause.squash(cause),
+              Cause.hasInterruptsOnly(cause),
+              cause
+            )
+
+            if (Cause.hasInterruptsOnly(cause)) {
+              if (toastId) yield* toast.dismiss(toastId)
+              return
+            }
+
+            const spanInfo = options.showSpanInfo !== false
+              ? yield* Effect.currentSpan.pipe(
+                Effect.map((span) => `\nTrace: ${span.traceId}\nSpan: ${span.spanId}`),
+                Effect.orElseSucceed(() => "")
+              )
+              : ""
+
+            const t = yield* wrapEffect(options.onFailure)(Cause.findErrorOption(cause), ...args)
+            const opts = { timeout: baseTimeout * 2, ...meta }
+
+            if (typeof t === "object") {
+              const message = t.message + spanInfo
+              return t.level === "warn"
+                ? yield* toast.warning(message, toastId !== undefined ? { ...opts, id: toastId } : opts)
+                : yield* toast.error(message, toastId !== undefined ? { ...opts, id: toastId } : opts)
+            }
+            yield* toast.error(t + spanInfo, toastId !== undefined ? { ...opts, id: toastId } : opts)
+          }, Effect.uninterruptible)),
+          toastId !== undefined ? Effect.provideService(CurrentToastId, CurrentToastId.of({ toastId })) : (_) => _
+        )
+      })
+  })
+}) {
+  static readonly DefaultWithoutDependencies = Layer.effect(this, this.make)
+  static readonly Default = this.DefaultWithoutDependencies
+
+  static readonly handle = <A, E, Args extends Array<unknown>, R, WaiR = never, SucR = never, ErrR = never>(
+    options: ToastOptions<A, E, Args, WaiR, SucR, ErrR>
+  ): (self: Effect.Effect<A, E, R>, ...args: Args) => Effect.Effect<A, E, R | WaiR | SucR | ErrR | WithToast> =>
+  (self, ...args) => this.use((_) => _<A, E, Args, R, WaiR, SucR, ErrR>(options)(self, ...args))
+}

package/test/dist/rpc-dynamic-middleware.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-dynamic-middleware.test.d.ts","sourceRoot":"","sources":["../rpc-dynamic-middleware.test.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAGrC,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACtE,OAAO,KAAK,OAAO,MAAM,mBAAmB,CAAA;AAC5C,OAAO,KAAK,IAAI,MAAM,eAAe,CAAA;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,CAAC,MAAM,kBAAkB,CAAA;;;;;;;;AASrC,cAAM,WAAY,SAAQ,gBAKzB;CAAG;;;;;;;AAeJ,cAAM,cAAe,SAAQ,mBAE3B;CAAG;;;;;;;;AAGL,cAAM,eAAgB,SAAQ,oBAG5B;CAAG;;;;;;;;;AASL,cAAM,aAAc,SAAQ,kBAIC;CAC3B;AAkDF,eAAO,MAAM,OAAO,+MAWlB,CAAA;AA4CF,eAAO,MAAM,SAAS,yNAAwC,CAAA;AA0G9D,eAAO,MAAM,gBAAgB,sRAA+C,CAAA"}