@effect-app/infra 4.0.0-beta.99 → 4.0.1

package/src/Store/codeFilter.ts

@@ -1,60 +1,109 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
-import { Array, Option } from "effect-app"
-import { assertUnreachable, get } from "effect-app/utils"
-import type { FilterR, FilterResult } from "../Model/filter/filterApi.js"
-import type { FieldValues } from "../Model/filter/types.js"
-import type { Filter } from "./service.js"
-import { compare, greaterThan, greaterThanExclusive, lowerThan, lowerThanExclusive } from "./utils.js"
+import * as Array from "effect-app/Array"
+import type { FilterR, FilterResult } from "effect-app/Model/filter/filterApi"
+import type { FieldValues } from "effect-app/Model/filter/types"
+import * as Option from "effect-app/Option"
+import type { Filter } from "effect-app/Store"
+import { absurd } from "effect/Function"
+import { compare, get, greaterThan, greaterThanExclusive, lowerThan, lowerThanExclusive, toJsonQueryValue } from "./utils.ts"
 
-const vAsArr = (v: string) => v as unknown as any[]
+const vAsArr = (v: unknown) => toJsonQueryValue(v) as any[]
+
+const mapEntries = (value: unknown): readonly [unknown, unknown][] => {
+  const json = toJsonQueryValue(value)
+  if (!Array.isArray(json)) return []
+  return json.filter((entry): entry is [unknown, unknown] => Array.isArray(entry) && entry.length >= 2)
+}
+
+const pairEq = (entry: readonly [unknown, unknown], pair: unknown) => {
+  const json = toJsonQueryValue(pair)
+  return Array.isArray(json) && json.length >= 2 && compare(entry[0], json[0]) && compare(entry[1], json[1])
+}
 
 const filterStatement = (x: any, p: FilterR) => {
-  const k = get(x, p.path)
+  const k = toJsonQueryValue(get(x, p.path))
+  const v = toJsonQueryValue(p.value)
   switch (p.op) {
     case "in":
-      return p.value.includes(k)
+      return (v as unknown[]).includes(k)
     case "notIn":
-      return !p.value.includes(k)
+      return !(v as unknown[]).includes(k)
     case "lt":
-      return lowerThan(k, p.value)
+      return lowerThan(k as any, v as any)
     case "lte":
-      return lowerThanExclusive(k, p.value)
+      return lowerThanExclusive(k as any, v as any)
     case "gt":
-      return greaterThan(k, p.value)
+      return greaterThan(k as any, v as any)
     case "gte":
-      return greaterThanExclusive(k, p.value)
+      return greaterThanExclusive(k as any, v as any)
     case "includes":
-      return (k as Array<string>).includes(p.value)
+      return (k as Array<unknown>).includes(v)
     case "notIncludes":
-      return !(k as Array<string>).includes(p.value)
+      return !(k as Array<unknown>).includes(v)
     case "includes-any":
-      return (vAsArr(p.value)).some((_) => (k as Array<string>)?.includes(_))
+      return (vAsArr(p.value)).some((_) => (k as Array<unknown>)?.includes(_))
     case "notIncludes-any":
-      return !(vAsArr(p.value)).some((_) => (k as Array<string>)?.includes(_))
+      return !(vAsArr(p.value)).some((_) => (k as Array<unknown>)?.includes(_))
     case "includes-all":
-      return (vAsArr(p.value)).every((_) => (k as Array<string>)?.includes(_))
+      return (vAsArr(p.value)).every((_) => (k as Array<unknown>)?.includes(_))
     case "notIncludes-all":
-      return !(vAsArr(p.value)).every((_) => (k as Array<string>)?.includes(_))
+      return !(vAsArr(p.value)).every((_) => (k as Array<unknown>)?.includes(_))
+    case "hasKey":
+      return mapEntries(k).some(([key]) => compare(key, v))
+    case "notHasKey":
+      return !mapEntries(k).some(([key]) => compare(key, v))
+    case "hasValue":
+      return mapEntries(k).some(([, val]) => compare(val, v))
+    case "notHasValue":
+      return !mapEntries(k).some(([, val]) => compare(val, v))
+    case "hasKeyValue":
+      return mapEntries(k).some((entry) => pairEq(entry, v))
+    case "notHasKeyValue":
+      return !mapEntries(k).some((entry) => pairEq(entry, v))
+    case "hasKey-any":
+      return vAsArr(p.value).some((key) => mapEntries(k).some(([k0]) => compare(k0, key)))
+    case "notHasKey-any":
+      return !vAsArr(p.value).some((key) => mapEntries(k).some(([k0]) => compare(k0, key)))
+    case "hasKey-all":
+      return vAsArr(p.value).every((key) => mapEntries(k).some(([k0]) => compare(k0, key)))
+    case "notHasKey-all":
+      return !vAsArr(p.value).every((key) => mapEntries(k).some(([k0]) => compare(k0, key)))
+    case "hasValue-any":
+      return vAsArr(p.value).some((val) => mapEntries(k).some(([, v0]) => compare(v0, val)))
+    case "notHasValue-any":
+      return !vAsArr(p.value).some((val) => mapEntries(k).some(([, v0]) => compare(v0, val)))
+    case "hasValue-all":
+      return vAsArr(p.value).every((val) => mapEntries(k).some(([, v0]) => compare(v0, val)))
+    case "notHasValue-all":
+      return !vAsArr(p.value).every((val) => mapEntries(k).some(([, v0]) => compare(v0, val)))
+    case "hasKeyValue-any":
+      return vAsArr(p.value).some((pair) => mapEntries(k).some((entry) => pairEq(entry, pair)))
+    case "notHasKeyValue-any":
+      return !vAsArr(p.value).some((pair) => mapEntries(k).some((entry) => pairEq(entry, pair)))
+    case "hasKeyValue-all":
+      return vAsArr(p.value).every((pair) => mapEntries(k).some((entry) => pairEq(entry, pair)))
+    case "notHasKeyValue-all":
+      return !vAsArr(p.value).every((pair) => mapEntries(k).some((entry) => pairEq(entry, pair)))
     case "contains":
-      return (k as string).toLowerCase().includes(p.value.toLowerCase())
+      return (k as string).toLowerCase().includes((v as string).toLowerCase())
     case "endsWith":
-      return (k as string).toLowerCase().endsWith(p.value.toLowerCase())
+      return (k as string).toLowerCase().endsWith((v as string).toLowerCase())
     case "startsWith":
-      return (k as string).toLowerCase().startsWith(p.value.toLowerCase())
+      return (k as string).toLowerCase().startsWith((v as string).toLowerCase())
     case "notContains":
-      return !(k as string).toLowerCase().includes(p.value.toLowerCase())
+      return !(k as string).toLowerCase().includes((v as string).toLowerCase())
     case "notEndsWith":
-      return !(k as string).toLowerCase().endsWith(p.value.toLowerCase())
+      return !(k as string).toLowerCase().endsWith((v as string).toLowerCase())
     case "notStartsWith":
-      return !(k as string).toLowerCase().startsWith(p.value.toLowerCase())
+      return !(k as string).toLowerCase().startsWith((v as string).toLowerCase())
     case "neq":
-      return !compare(k, p.value)
+      return !compare(k, v)
     case "eq":
     case undefined:
-      return compare(k, p.value)
+      return compare(k, v)
     default: {
-      return assertUnreachable(p.op)
+      return absurd(p.op)
     }
   }
 }
@@ -186,6 +235,7 @@ export const codeFilter3_ = <E>(state: readonly FilterResult[], sut: E): boolean
   const statements: any[] = [] // must be defined here to be used by eval.
   // always put everything inside a root scope.
   const s = codeFilter3__([{ t: "where-scope", result: state, relation: "some" }], sut, statements, null, false)
+  // oxlint-disable-next-line no-eval
   return eval(s)
 }
 

package/src/Store/index.ts

@@ -1,14 +1,21 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, Layer, Redacted } from "effect-app"
-import { CosmosStoreLayer } from "./Cosmos.js"
-import { DiskStoreLayer } from "./Disk.js"
-import { MemoryStoreLive } from "./Memory.js"
-// import { RedisStoreLayer } from "./Redis.js"
-import type { StorageConfig } from "./service.js"
-import { SQLiteStoreLayer } from "./SQL.js"
-import { PgStoreLayer } from "./SQL/Pg.js"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import { RepositoryRegistryLive } from "effect-app/Model"
+import type { StorageConfig } from "effect-app/Store"
+import * as Redacted from "effect/Redacted"
+import type { SqlClient } from "effect/sql"
+import { CosmosStoreLayer } from "./Cosmos.ts"
+import { DiskStoreLayer } from "./Disk.ts"
+import { MemoryStoreLive } from "./Memory.ts"
+// import { RedisStoreLayer } from "./Redis.ts"
+import { SQLiteStoreLayer } from "./SQL.ts"
+import { PgStoreLayer } from "./SQL/Pg.ts"
 
-export function StoreMakerLayer(cfg: StorageConfig) {
+export function StoreMakerLayer(
+  cfg: StorageConfig,
+  options?: { makeSqlClientLayer?: (namespace: string) => Layer.Layer<SqlClient.SqlClient> }
+) {
   return Effect
     .sync(() => {
       const storageUrl = Redacted.value(cfg.url)
@@ -23,7 +30,7 @@ export function StoreMakerLayer(cfg: StorageConfig) {
       }
       if (storageUrl.startsWith("sqlite://")) {
         console.log("Using SQLite store")
-        return SQLiteStoreLayer(cfg)
+        return SQLiteStoreLayer(cfg, options)
       }
       if (storageUrl.startsWith("pg://")) {
         console.log("Using PostgreSQL store")
@@ -37,7 +44,5 @@ export function StoreMakerLayer(cfg: StorageConfig) {
       console.log("Using Cosmos DB store")
       return CosmosStoreLayer(cfg)
     })
-    .pipe(Layer.unwrap)
+    .pipe(Layer.unwrap, Layer.merge(RepositoryRegistryLive))
 }
-
-export * from "./service.js"

package/src/Store/jsonDocument.ts

@@ -0,0 +1,143 @@
+import type { FieldValues } from "effect-app/Model/filter/types"
+import * as Option from "effect-app/Option"
+import * as S from "effect-app/Schema"
+import type { PersistenceModelType, StoreConfig } from "effect-app/Store"
+import * as Result from "effect/Result"
+import { toJsonQueryValue } from "./utils.ts"
+
+export interface JsonDocumentCodec<E extends FieldValues> {
+  readonly encode: (doc: PersistenceModelType<E>) => PersistenceModelType<E>
+  readonly decode: (doc: PersistenceModelType<E>) => PersistenceModelType<E>
+}
+
+/**
+ * The store *read* boundary decode: a stored JSON document in, either the
+ * Encoded document or the `S.SchemaError` saying why it is not one.
+ *
+ * Synchronous on purpose: it runs once per document over whole result sets, so
+ * it must not allocate an Effect per row. Adapters lift the `Result` into their
+ * Effect channel once per operation (see {@link decodeStoredMany}).
+ */
+export type StoredDecode<E extends FieldValues> = (
+  doc: PersistenceModelType<E>
+) => Result.Result<PersistenceModelType<E>, S.SchemaError>
+
+const splitEtag = <E extends FieldValues>(doc: PersistenceModelType<E>) => {
+  const { _etag, ...rest } = doc
+  return { rest: rest as E, _etag }
+}
+
+const joinEtag = <E extends FieldValues>(
+  rest: E,
+  _etag: string | undefined
+): PersistenceModelType<E> => (_etag === undefined ? rest : { ...rest, _etag })
+
+/** JSON document ↔ Encoded document codec for a store's domain schema. */
+const jsonCodec = <E extends FieldValues>(schema: S.Top) => S.toCodecJson(S.toEncoded(schema)) as S.Codec<E, S.Json>
+
+/**
+ * Encoded document ↔ JSON document. Prefer `Schema.toCodecJson(toEncoded(schema))`
+ * when the store has a schema; otherwise lower Date/Map/Set structurally.
+ *
+ * Both directions are **strict**: they run the whole-document codec, so a
+ * document that does not match the Encoded shape fails loudly rather than being
+ * read back half-decoded.
+ *
+ * This is the **write** path codec: `encode` on the way to the database, and
+ * `decode` to hand the just-written document back. The read path uses
+ * {@link makeStoredDecode}, which applies `jitM` first and reports a document it
+ * does not repair as a typed `S.SchemaError` instead of throwing.
+ *
+ * `_etag` is infrastructure metadata rather than part of the domain document,
+ * so it is split off before the codec runs and re-attached afterwards.
+ */
+export const makeJsonDocumentCodec = <E extends FieldValues>(schema?: S.Top): JsonDocumentCodec<E> => {
+  if (schema) {
+    const codec = jsonCodec<E>(schema)
+    return {
+      encode: (doc) => {
+        const { rest, _etag } = splitEtag(doc)
+        return joinEtag(S.encodeSync(codec)(rest) as E, _etag)
+      },
+      decode: (doc) => {
+        const { rest, _etag } = splitEtag(doc)
+        return joinEtag(S.decodeSync(codec)(rest as S.Json), _etag)
+      }
+    }
+  }
+  return {
+    encode: (doc) => toJsonQueryValue(doc) as PersistenceModelType<E>,
+    decode: (doc) => doc
+  }
+}
+
+/**
+ * The store *read* boundary: apply `jitM` to the raw JSON document - after the
+ * adapter merged `defaultValues` into it - and only then decode JSON→Encoded
+ * with the strict `Schema.toCodecJson(Schema.toEncoded(schema))` codec.
+ *
+ * This is the one place a legacy-shaped document can be repaired, and why
+ * `jitM` can fix things no schema decode could - an explicit `null` where a
+ * `Date` is expected, a key added after the document was written. It runs
+ * before any schema decode sees the document.
+ *
+ * Nothing here is lenient: a document `jitM` does not repair still fails. It
+ * fails as a typed `S.SchemaError` in a `Result` (via `S.decodeUnknownResult`)
+ * rather than by throwing, so adapters can turn it into `Effect.fail` and
+ * callers - `Repository.validateSample` in particular - can inspect it per
+ * document instead of losing the whole run to a defect.
+ *
+ * `_etag` is infrastructure metadata rather than part of the domain document,
+ * so it is split off first and `jitM` never sees it.
+ */
+export const makeStoredDecode = <E extends FieldValues>(
+  schema: StoreConfig<E>["schema"],
+  jitM: StoreConfig<E>["jitM"]
+): StoredDecode<E> => {
+  if (schema === undefined) {
+    // schemaless store: the stored document is already the Encoded document,
+    // so there is nothing to decode - only `jitM` to apply.
+    if (jitM === undefined) return Result.succeed
+    return (doc) => {
+      const { rest, _etag } = splitEtag(doc)
+      return Result.succeed(joinEtag(jitM(rest) as unknown as E, _etag))
+    }
+  }
+  const decode = S.decodeUnknownResult(jsonCodec<E>(schema))
+  return (doc) => {
+    const { rest, _etag } = splitEtag(doc)
+    // adapters type the stored document as the Encoded persistence model, but
+    // at this point it is still the raw JSON document that `jitM` is written
+    // against - and `jitM` returns JSON, which is what the codec consumes.
+    const json = jitM === undefined ? rest : jitM(rest) as unknown as E
+    return Result.map(decode(json), (decoded) => joinEtag(decoded, _etag))
+  }
+}
+
+/**
+ * Decode a whole result set, failing fast on the first bad document.
+ *
+ * One synchronous loop and one `Result` for the batch: no Effect per document,
+ * and no allocation beyond the decoded array (plus a `Result` wrapper) on the
+ * happy path. Adapters lift the returned `Result` with `Effect.fromResult`
+ * once, at the end.
+ */
+export const decodeStoredMany = <A, B>(
+  docs: readonly A[],
+  decode: (doc: A) => Result.Result<B, S.SchemaError>
+): Result.Result<B[], S.SchemaError> => {
+  const decoded: B[] = []
+  for (const doc of docs) {
+    const result = decode(doc)
+    if (Result.isFailure(result)) return Result.fail(result.failure)
+    decoded.push(result.success)
+  }
+  return Result.succeed(decoded)
+}
+
+/** Decode an optional stored document; `None` short-circuits without decoding. */
+export const decodeStoredOption = <A, B>(
+  doc: Option.Option<A>,
+  decode: (doc: A) => Result.Result<B, S.SchemaError>
+): Result.Result<Option.Option<B>, S.SchemaError> =>
+  Option.isNone(doc) ? Result.succeed(Option.none()) : Result.map(decode(doc.value), Option.some)