effect-app 4.0.0-beta.29 → 4.0.0-beta.291

package/src/Store.ts

@@ -0,0 +1,273 @@
+/* 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.ts"
+import type { DatabaseError, OptimisticConcurrencyException } from "./client/errors.ts"
+import * as Context from "./Context.ts"
+import * as Effect from "./Effect.ts"
+import type { FilterResult } from "./Model/filter/filterApi.ts"
+import type { FieldValues } from "./Model/filter/types.ts"
+import type { FieldPath } from "./Model/filter/types/path/index.ts"
+import type { AggregateIrExpression, ComputedProjectionIrExpression, RawQuery } from "./Model/query.ts"
+import type * as Option from "./Option.ts"
+import * as RequestScopedDependencies from "./RequestScopedDependencies.ts"
+import { NonEmptyString255 } from "./Schema.ts"
+
+/**
+ * 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>)[], DatabaseError>
+
+export interface Store<
+  IdKey extends keyof Encoded,
+  Encoded extends FieldValues,
+  PM extends PersistenceModelType<Encoded> = PersistenceModelType<Encoded>
+> {
+  all: Effect.Effect<PM[], DatabaseError>
+  filter: FilterFunc<Encoded>
+  find: (id: Encoded[IdKey]) => Effect.Effect<Option.Option<PM>, DatabaseError>
+  set: (e: PM) => Effect.Effect<PM, OptimisticConcurrencyException | DatabaseError>
+  batchSet: (
+    items: NonEmptyReadonlyArray<PM>
+  ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException | DatabaseError>
+  bulkSet: (
+    items: NonEmptyReadonlyArray<PM>
+  ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException | DatabaseError>
+  batchRemove: (ids: NonEmptyReadonlyArray<Encoded[IdKey]>, partitionKey?: string) => Effect.Effect<void, DatabaseError>
+  queryRaw: <Out>(query: RawQuery<Encoded, Out>) => Effect.Effect<readonly Out[], DatabaseError>
+  /**
+   * 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, DatabaseError>
+}
+
+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 const ContextMapContainer = RequestScopedDependencies.make(
+  "ContextMapContainer",
+  ContextMap.make.pipe(Effect.map(ContextMap.of))
+)
+
+export type ContextMapNotStartedError = RequestScopedDependencies.RequestScopedDependencyNotStartedError
+
+export const getContextMap = ContextMapContainer.current
+
+/**
+ * Runs `make` at most once per ContextMap (i.e. per request) and caches the
+ * resulting value in the ContextMap under a fresh symbol. Subsequent calls of
+ * the returned Effect within the same ContextMap return the cached value.
+ *
+ * Uses the ContextMap's shared semaphore for safe single initialization.
+ */
+export const cachedPerRequest = <A, E, R>(
+  make: Effect.Effect<A, E, R>
+): Effect.Effect<A, E | ContextMapNotStartedError, R> => {
+  const cacheKey = Symbol()
+  return getContextMap.pipe(
+    Effect.flatMap((ctxMap) => ctxMap.getOrCreateStoreEffect(cacheKey, make))
+  )
+}
+
+const defaultNs: NonEmptyString255 = NonEmptyString255("primary")
+export class storeId extends Context.Reference("StoreId", { defaultValue: (): NonEmptyString255 => defaultNs }) {}
+
+export type PersistenceModelType<Encoded extends object> = Encoded & {
+  _etag?: string | undefined
+}
+
+export interface StorageConfig {
+  url: Redacted.Redacted
+  prefix: string
+  dbName: string
+}

package/src/_ext/Array.ts

@@ -1,5 +1,7 @@
-import { Chunk, Effect, Equal } from "effect-app"
-import { NotFoundError } from "../client/errors.js"
+import * as Chunk from "effect-app/Chunk"
+import * as Effect from "effect-app/Effect"
+import * as Equal from "effect/Equal"
+import { NotFoundError } from "../client/errors.ts"
 
 function getFirstBy<A, Type extends string>(
   a: Iterable<A>,

package/src/_ext/misc.ts

@@ -1,5 +1,8 @@
-import { Effect, Option, Result, type Scope } from "effect"
 import type { LazyArg } from "effect-app/Function"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import * as Result from "effect/Result"
+import type * as Scope from "effect/Scope"
 
 export type _R<T extends Effect.Effect<any, any, any>> = [T] extends [
   Effect.Effect<any, any, infer R>

package/src/_ext/ord.ext.ts

@@ -1,4 +1,5 @@
-import { Chunk, type Equivalence } from "effect"
+import * as Chunk from "effect/Chunk"
+import type * as Equivalence from "effect/Equivalence"
 
 export function toArray<A>(
   gen: Generator<A, void, unknown>

package/src/builtin-json.d.ts

@@ -0,0 +1,24 @@
+// JSON / Body return-type overrides (`any` -> `unknown`), isolated from
+// `builtin.ts` so consumers that source-link this package (e.g. an embedded
+// Effect-source setup) can toggle them off. As a `declare global`, the override
+// is program-wide: in linked mode it leaks into source-linked Effect and breaks
+// Effect's own `JSON.parse(...)` / `response.json()` call sites (TS2322
+// `unknown` vs `Json`). `builtin.ts` triple-slash-references this file, so
+// normal builds keep the override.
+declare global {
+  interface JSON {
+    /**
+     * Converts a JavaScript Object Notation (JSON) string into an object.
+     * @param text A valid JSON string.
+     * @param reviver A function that transforms the results. This function is called for each member of the object.
+     * If a member contains nested objects, the nested objects are transformed before the parent object is.
+     */
+    parse(text: string, reviver?: (this: any, key: string, value: any) => any): unknown
+  }
+
+  interface Body {
+    json(): Promise<unknown>
+  }
+}
+
+export {}

package/src/builtin.ts

@@ -1,3 +1,5 @@
+// oxlint-disable-next-line typescript/triple-slash-reference
+/// <reference path="./builtin-json.d.ts" />
 import type { NonEmptyArray, NonEmptyReadonlyArray } from "effect/Array"
 
 declare global {
@@ -17,34 +19,27 @@ declare global {
     split(separator: string | RegExp, limit?: number): [string, ...string[]]
   }
 
-  interface JSON {
-    /**
-     * Converts a JavaScript Object Notation (JSON) string into an object.
-     * @param text A valid JSON string.
-     * @param reviver A function that transforms the results. This function is called for each member of the object.
-     * If a member contains nested objects, the nested objects are transformed before the parent object is.
-     */
-    parse(text: string, reviver?: (this: any, key: string, value: any) => any): unknown
-  }
-
-  interface Body {
-    json(): Promise<unknown>
-  }
+  // JSON.parse / Body.json overrides live in ./builtin-json.d.ts (referenced
+  // above) so a source-linked consumer can disable them in linked mode.
 
   interface Array<T> {
-    map<A, B>(
-      this: NonEmptyArray<A>,
-      map: (a: A, index: number) => B
-    ): NonEmptyArray<B>
+    // Conditional return instead of a `this`-typed overload: a `this` overload
+    // is selected-then-rejected on union-of-array receivers (TS2684), poisoning
+    // foreign code like `(readonly A[] | readonly B[]).map(...)`. A single
+    // conditional-return signature refines NonEmpty without a `this` param.
+    map<U>(
+      callbackfn: (value: T, index: number, array: T[]) => U,
+      thisArg?: any
+    ): this extends NonEmptyArray<any> ? NonEmptyArray<U> : U[]
   }
   interface ReadonlyArray<T> {
     // Subsequent property declarations must have the same type.  Property 'length' must be of type 'number', but here has type 'NonNegativeInt'.
     // readonly length: NonNegativeInt
 
-    map<A, B>(
-      this: NonEmptyReadonlyArray<A>,
-      map: (a: A, index: number) => B
-    ): NonEmptyReadonlyArray<B>
+    map<U>(
+      callbackfn: (value: T, index: number, array: readonly T[]) => U,
+      thisArg?: any
+    ): this extends NonEmptyReadonlyArray<any> ? NonEmptyReadonlyArray<U> : U[]
   }
 }
 

package/src/client/InvalidationKeys.ts

@@ -0,0 +1,50 @@
+import * as Ref from "effect/Ref"
+import * as Context from "../Context.ts"
+import * as Effect from "../Effect.ts"
+import type { InvalidationKey } from "../rpc/Invalidation.ts"
+
+export type { InvalidationKey }
+/** Shape of the per-mutation service that accumulates server-provided invalidation keys. */
+export interface InvalidationKeysService {
+  readonly add: (key: InvalidationKey) => Effect.Effect<void>
+  readonly get: Effect.Effect<ReadonlyArray<InvalidationKey>>
+}
+
+/**
+ * Context.Reference that accumulates invalidation keys received from the server via the
+ * `x-invalidate` HTTP response header.
+ *
+ * The default is a no-op: when not explicitly provided (e.g. outside a mutation wrapper)
+ * all calls are ignored. The mutation wrapper in `@effect-app/vue` provides a real
+ * implementation backed by a `Ref`.
+ */
+export const InvalidationKeysFromServer = Context.Reference<InvalidationKeysService>(
+  "effect-app/client/InvalidationKeysFromServer",
+  {
+    defaultValue: () => ({
+      add: (_key: InvalidationKey) => Effect.void,
+      get: Effect.succeed([] as ReadonlyArray<InvalidationKey>)
+    })
+  }
+)
+export type InvalidationKeysFromServer = typeof InvalidationKeysFromServer
+
+/**
+ * Creates a fresh `InvalidationKeysService` implementation backed by a `Ref`.
+ *
+ * @param ref - The `Ref` that stores the accumulated keys.
+ * @param onAdded - V3: Optional Effect run after a key is added. Use to trigger mid-stream
+ *   query invalidation without waiting for the stream to complete.
+ */
+export const makeInvalidationKeysService = (
+  ref: Ref.Ref<ReadonlyArray<InvalidationKey>>,
+  onAdded?: (key: InvalidationKey) => Effect.Effect<void>
+): InvalidationKeysService => ({
+  // When onAdded is set, fire it immediately without accumulating in the ref —
+  // the key is handled on arrival and must not be re-processed at stream end.
+  add: (key) =>
+    onAdded
+      ? onAdded(key)
+      : Ref.update(ref, (keys) => [...keys, key]),
+  get: Ref.get(ref)
+})