@effect-app/infra 0.210.11 → 0.211.1

package/src/services/Store/Cosmos.ts

@@ -4,24 +4,11 @@ import { toNonEmptyArray } from "@effect-app/core/Array"
 import { CosmosClient, CosmosClientLayer } from "@effect-app/infra-adapters/cosmos-client"
 import { Chunk, Duration, Effect, Layer, Option, ReadonlyArray, Secret } from "effect-app"
 import type { NonEmptyReadonlyArray } from "effect-app"
-import { dropUndefinedT, omit, pick, spread } from "effect-app/utils"
+import { dropUndefinedT, omit, pick } from "effect-app/utils"
 import { OptimisticConcurrencyException } from "../../errors.js"
-import {
-  buildCosmosQuery,
-  buildFilterJoinSelectCosmosQuery,
-  buildFindJoinCosmosQuery,
-  buildWhereCosmosQuery3,
-  logQuery
-} from "./Cosmos/query.js"
+import { buildWhereCosmosQuery3, logQuery } from "./Cosmos/query.js"
 import { StoreMaker } from "./service.js"
-import type {
-  FilterArgs,
-  FilterJoinSelect,
-  PersistenceModelType,
-  StorageConfig,
-  Store,
-  StoreConfig
-} from "./service.js"
+import type { FilterArgs, PersistenceModelType, StorageConfig, Store, StoreConfig } from "./service.js"
 
 class CosmosDbOperationError {
   constructor(readonly message: string) {}
@@ -213,15 +200,14 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                 parameters: [{ name: "@id", value: importedMarkerId }]
               }))
               .pipe(
-                Effect
-                  .tap((q) => logQuery(q)),
+                Effect.tap((q) => logQuery(q)),
                 Effect.flatMap((q) =>
                   Effect.promise(() =>
                     container
                       .items
                       .query<PM>(q)
                       .fetchAll()
-                      .then(({ resources }) => resources)
+                      .then(({ resources }) => resources.map((_) => ({ ...defaultValues, ..._ })))
                   )
                 ),
                 Effect
@@ -229,48 +215,6 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                     attributes: { "repository.container_id": containerId, "repository.model_name": name }
                   })
               ),
-            filterJoinSelect: <T extends object>(
-              filter: FilterJoinSelect,
-              cursor?: { skip?: number; limit?: number }
-            ) =>
-              Effect
-                .forEach(
-                  filter
-                    .keys,
-                  (k) =>
-                    Effect
-                      .sync(() => buildFilterJoinSelectCosmosQuery(filter, k, name, cursor?.skip, cursor?.limit))
-                      .pipe(
-                        Effect
-                          .tap((q) => logQuery(q)),
-                        Effect.flatMap((q) =>
-                          Effect.promise(() =>
-                            container
-                              .items
-                              .query<T>(q)
-                              .fetchAll()
-                              .then(({ resources }) => resources.map((_) => ({ ...defaultValues, ..._ })))
-                          )
-                        )
-                      )
-                )
-                .pipe(
-                  Effect.map((a) => {
-                    const v = a
-                      .flatMap((_) => _)
-                      .map((x) =>
-                        spread(
-                          x,
-                          ({ r, ...rest }: any) => ({ ...rest, ...r } as T & { _rootId: string })
-                        )
-                      )
-                    return v
-                  }),
-                  Effect
-                    .withSpan("Cosmos.filterJoinSelect [effect-app/infra/Store]", {
-                      attributes: { "repository.container_id": containerId, "repository.model_name": name }
-                    })
-                ),
             /**
              * May return duplicate results for "join_find", when matching more than once.
              */
@@ -281,82 +225,40 @@ function makeCosmosStore({ prefix }: StorageConfig) {
               const limit = f?.limit
               const filter = f.filter ?? { type: "new-kid", build: () => [] }
               type M = U extends undefined ? PM : Pick<PM, U>
-              return (filter.type === "join_find"
-                // This is a problem if one of the multiple joined arrays can be empty!
-                // https://stackoverflow.com/questions/60320780/azure-cosmosdb-sql-join-not-returning-results-when-the-child-contains-empty-arra
-                // so we use multiple queries instead.
-                ? Effect
-                  .forEach(
-                    filter
-                      .keys,
-                    (k) =>
-                      Effect
-                        .sync(() => buildFindJoinCosmosQuery(filter, k, name, skip, limit))
-                        .pipe(
-                          Effect.tap((q) => logQuery(q)),
-                          Effect
-                            .flatMap((q) =>
-                              Effect.promise(() =>
-                                container
-                                  .items
-                                  .query<M>(q)
-                                  .fetchAll()
-                                  .then(({ resources }) => resources.map((_) => ({ ...defaultValues, ..._ })))
-                              )
-                            )
-                        )
+              return Effect
+                .sync(() =>
+                  buildWhereCosmosQuery3(
+                    filter.build(),
+                    name,
+                    importedMarkerId,
+                    defaultValues,
+                    f.select as NonEmptyReadonlyArray<string> | undefined,
+                    f.order as NonEmptyReadonlyArray<{ key: string; direction: "ASC" | "DESC" }> | undefined,
+                    skip,
+                    limit
                   )
-                  .pipe(Effect.map((_) => _.flatMap((_) => _)))
-                : (filter.type === "new-kid"
-                  ? Effect
-                    .sync(() =>
-                      buildWhereCosmosQuery3(
-                        filter.build(),
-                        name,
-                        importedMarkerId,
-                        defaultValues,
-                        f.select as NonEmptyReadonlyArray<string> | undefined,
-                        f.order as NonEmptyReadonlyArray<{ key: string; direction: "ASC" | "DESC" }> | undefined,
-                        skip,
-                        limit
+                )
+                .pipe(
+                  Effect.tap((q) => logQuery(q)),
+                  Effect
+                    .flatMap((q) =>
+                      Effect.promise(() =>
+                        f.select
+                          ? container
+                            .items
+                            .query<M>(q)
+                            .fetchAll()
+                            .then(({ resources }) =>
+                              resources.map((_) => ({ ...pick(defaultValues, f.select!), ..._ }))
+                            )
+                          : container
+                            .items
+                            .query<{ f: M }>(q)
+                            .fetchAll()
+                            .then(({ resources }) => resources.map((_) => ({ ...defaultValues, ..._.f })))
                       )
                     )
-                    .pipe(
-                      Effect.tap((q) => logQuery(q)),
-                      Effect
-                        .flatMap((q) =>
-                          Effect.promise(() =>
-                            f.select
-                              ? container
-                                .items
-                                .query<M>(q)
-                                .fetchAll()
-                                .then(({ resources }) =>
-                                  resources.map((_) => ({ ...pick(defaultValues, f.select!), ..._ }))
-                                )
-                              : container
-                                .items
-                                .query<{ f: M }>(q)
-                                .fetchAll()
-                                .then(({ resources }) => resources.map((_) => ({ ...defaultValues, ..._.f })))
-                          )
-                        )
-                    )
-                  : Effect
-                    .sync(() => buildCosmosQuery(filter, name, importedMarkerId, defaultValues, skip, limit))
-                    .pipe(
-                      Effect.tap((q) => logQuery(q)),
-                      Effect
-                        .flatMap((q) =>
-                          Effect.promise(() =>
-                            container
-                              .items
-                              .query<{ f: M }>(q)
-                              .fetchAll()
-                              .then(({ resources }) => resources.map((_) => ({ ...defaultValues, ..._.f })))
-                          )
-                        )
-                    )))
+                )
                 .pipe(Effect.withSpan("Cosmos.filter [effect-app/infra/Store]", {
                   attributes: { "repository.container_id": containerId, "repository.model_name": name }
                 }))
@@ -468,7 +370,8 @@ function makeCosmosStore({ prefix }: StorageConfig) {
               Effect.promise(() =>
                 container.items.create({
                   _partitionKey: importedMarkerId,
-                  id: importedMarkerId
+                  id: importedMarkerId,
+                  ttl: -1
                 })
               )
             )

package/src/services/Store/Disk.ts

@@ -150,7 +150,6 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
             all: Effect.flatMap(getStore, (_) => _.all),
             find: (...args) => Effect.flatMap(getStore, (_) => _.find(...args)),
             filter: (...args) => Effect.flatMap(getStore, (_) => _.filter(...args)),
-            filterJoinSelect: (...args) => Effect.flatMap(getStore, (_) => _.filterJoinSelect(...args)),
             set: (...args) => Effect.flatMap(getStore, (_) => _.set(...args)),
             batchSet: (...args) => Effect.flatMap(getStore, (_) => _.batchSet(...args)),
             bulkSet: (...args) => Effect.flatMap(getStore, (_) => _.bulkSet(...args)),

package/src/services/Store/Memory.ts

@@ -4,9 +4,9 @@ import { Effect, FiberRef, flow, Option, Order, pipe, ReadonlyArray, Ref } from
 import type { NonEmptyArray, NonEmptyReadonlyArray } from "effect-app"
 import { get, pick } from "effect-app/utils"
 import type { RequestContext } from "../../RequestContext.js"
-import type { FilterArgs, FilterJoinSelect, PersistenceModelType, Store, StoreConfig } from "./service.js"
+import type { FilterArgs, PersistenceModelType, Store, StoreConfig } from "./service.js"
 import { StoreMaker } from "./service.js"
-import { codeFilter, codeFilterJoinSelect, makeUpdateETag } from "./utils.js"
+import { codeFilter, makeUpdateETag } from "./utils.js"
 
 export function memFilter<T extends PersistenceModelType<string>, U extends keyof T = never>(f: FilterArgs<T, U>) {
   type M = U extends undefined ? T : Pick<T, U>
@@ -149,20 +149,6 @@ export function makeMemoryStoreInt<Id extends string, PM extends PersistenceMode
               attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
             })
           ),
-      filterJoinSelect: <T extends object>(filter: FilterJoinSelect) =>
-        all
-          .pipe(
-            Effect.map((c) => c.flatMap(codeFilterJoinSelect<PM, T>(filter))),
-            Effect
-              .withSpan(
-                "Memory.filterJoinSelect [effect-app/infra/Store]",
-                {
-                  attributes: {
-                    modelName
-                  }
-                }
-              )
-          ),
       set: (e) =>
         s
           .find(e.id)
@@ -257,7 +243,6 @@ export const makeMemoryStore = () => ({
         all: Effect.flatMap(getStore, (_) => _.all),
         find: (...args) => Effect.flatMap(getStore, (_) => _.find(...args)),
         filter: (...args) => Effect.flatMap(getStore, (_) => _.filter(...args)),
-        filterJoinSelect: (...args) => Effect.flatMap(getStore, (_) => _.filterJoinSelect(...args)),
         set: (...args) => Effect.flatMap(getStore, (_) => _.set(...args)),
         batchSet: (...args) => Effect.flatMap(getStore, (_) => _.batchSet(...args)),
         bulkSet: (...args) => Effect.flatMap(getStore, (_) => _.bulkSet(...args)),

package/src/services/Store/Redis.ts.bak

@@ -4,9 +4,9 @@ import { Effect, Layer, Option, ReadonlyArray, Secret } from "effect-app"
 import type { NonEmptyArray, NonEmptyReadonlyArray } from "effect-app"
 import { NotFoundError } from "../../errors.js"
 import { memFilter } from "./Memory.js"
-import type { FilterJoinSelect, PersistenceModelType, StorageConfig, Store, StoreConfig } from "./service.js"
+import type { PersistenceModelType, StorageConfig, Store, StoreConfig } from "./service.js"
 import { StoreMaker } from "./service.js"
-import { codeFilterJoinSelect, makeETag, makeUpdateETag } from "./utils.js"
+import { makeETag, makeUpdateETag } from "./utils.js"
 
 function makeRedisStore({ prefix }: StorageConfig) {
   return Effect.gen(function*($) {
@@ -61,8 +61,6 @@ function makeRedisStore({ prefix }: StorageConfig) {
           const s: Store<PM, Id> = {
             all,
             filter: (f) => all.map(memFilter(f)),
-            filterJoinSelect: <T extends object>(filter: FilterJoinSelect) =>
-              all.map((c) => c.flatMap(codeFilterJoinSelect<PM, T>(filter))),
             find: (id) => asMap.map((_) => Option.fromNullable(_.get(id))),
             set: (e) =>
               s

package/src/services/Store/filterApi/query.ts

@@ -210,11 +210,11 @@ export type Filts<TFieldValues extends FieldValues> = {
   ): QueryBuilder<TFieldValues>
   <
     TFieldName extends FieldPath<TFieldValues>,
-    V extends FieldPathValue<TFieldValues, TFieldName>
+    V extends string
   >(
     path: TFieldName,
     op: "startsWith" | "endsWith" | "contains" | "notContains" | "notStartsWith" | "notEndsWith",
-    value: V // only strings?
+    value: V
   ): QueryBuilder<TFieldValues>
   <
     TFieldName extends FieldPath<TFieldValues>,

package/src/services/Store/service.ts

@@ -34,37 +34,7 @@ export type Where =
     value: readonly (SupportedValues)[]
   }
 
-// default is where
-export type StoreWhereFilter = {
-  type?: "where" | undefined
-  mode?: "and" | "or" | undefined // default is and
-  where: readonly [
-    Where,
-    ...(Where[])
-  ]
-}
-export type LegacyFilter<E> =
-  | { by: keyof E; type: "startsWith"; value: any }
-  | { by: keyof E; type: "endsWith"; value: any }
-  | { by: keyof E; type: "contains"; value: any }
-export type JoinFindFilter = {
-  type: "join_find"
-  keys: readonly string[] /* value paths of E */
-  valueKey: string /* value paths of E[keys][valueKey] */
-  value: any /* value path[valueKey] of E */
-}
-export type Filter<E extends FieldValues> =
-  | JoinFindFilter
-  | StoreWhereFilter
-  | LegacyFilter<E>
-  | QueryBuilder<E>
-
-export type FilterJoinSelect = {
-  type: "filter_join_select"
-  keys: readonly string[] /* value paths of E */
-  valueKey: string /* value paths of E[keys][valueKey] */
-  value: any /* value path[valueKey] of E */
-}
+export type Filter<E extends FieldValues> = QueryBuilder<E>
 
 export interface O<PM extends PersistenceModelType<unknown>> {
   key: keyof PM
@@ -86,10 +56,6 @@ export type FilterFunc<PM extends PersistenceModelType<unknown>> = <U extends ke
 export interface Store<PM extends PersistenceModelType<Id>, Id> {
   all: Effect<PM[]>
   filter: FilterFunc<PM>
-  /** @deprecated */
-  filterJoinSelect: <T extends object>(
-    filter: FilterJoinSelect
-  ) => Effect<(T & { _rootId: string })[]>
   find: (id: Id) => Effect<Option<PM>>
   set: (e: PM) => Effect<PM, OptimisticConcurrencyException>
   batchSet: (

package/src/services/Store/utils.ts

@@ -1,9 +1,8 @@
-import { Effect, Option, ReadonlyArray } from "effect-app"
-import { get } from "effect-app/utils"
+import { Effect, Option } from "effect-app"
 import objectHash from "object-hash"
 import { OptimisticConcurrencyException } from "../../errors.js"
 import { codeFilter3_ } from "./codeFilter.js"
-import type { Filter, FilterJoinSelect, PersistenceModelType, SupportedValues2 } from "./service.js"
+import type { Filter, PersistenceModelType, SupportedValues2 } from "./service.js"
 
 export const makeETag = <E extends PersistenceModelType<Id>, Id extends string>(
   { _etag, ...e }: E
@@ -37,155 +36,7 @@ export const makeUpdateETag =
     })
 
 export function codeFilter<E extends { id: string }, NE extends E>(filter: Filter<NE>) {
-  return (x: E) =>
-    filter.type === "new-kid"
-      ? codeFilter3_(filter.build(), x) ? Option.some(x as unknown as NE) : Option.none()
-      : filter.type === "startsWith"
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ? lowercaseIfString((x as any)[filter.by]).startsWith(filter.value.toLowerCase())
-        ? Option.some(x as unknown as NE)
-        : Option.none()
-      : filter.type === "endsWith"
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ? lowercaseIfString((x as any)[filter.by]).endsWith(filter.value.toLowerCase())
-        ? Option.some(x as unknown as NE)
-        : Option.none()
-      : filter.type === "contains"
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-      ? lowercaseIfString((x as any)[filter.by]).includes(filter.value.toLowerCase())
-        ? Option.some(x as unknown as NE)
-        : Option.none()
-      : filter.type === "join_find"
-      ? filter.keys.some((k) => {
-          const value = get(x, k) as Record<string, unknown>[]
-          // we mimic the behavior of cosmosdb; if the shape in db does not match what we're looking for, we imagine false hit
-          return (
-            value
-            && value.some((v) => compare(v[filter.valueKey], filter.value))
-          )
-        })
-        ? Option.some(x as unknown as NE)
-        : Option.none()
-      // TODO: support mixed or/and
-      : filter.mode === "or"
-      ? filter
-          .where
-          .some((p) => {
-            const k = get(x, p.key)
-            switch (p.t) {
-              case "in":
-                return p.value.includes(k)
-              case "not-in":
-                return !p.value.includes(k)
-              case "lt":
-                return lowerThan(k, p.value)
-              case "lte":
-                return lowerThanExclusive(k, p.value)
-              case "gt":
-                return greaterThan(k, p.value)
-              case "gte":
-                return greaterThanExclusive(k, p.value)
-              case "includes":
-                return (k as Array<string>).includes(p.value)
-              case "not-includes":
-                return !(k as Array<string>).includes(p.value)
-              case "contains":
-                return (k as string).toLowerCase().includes(p.value.toLowerCase())
-              case "ends-with":
-                return (k as string).toLowerCase().endsWith(p.value.toLowerCase())
-              case "starts-with":
-                return (k as string).toLowerCase().startsWith(p.value.toLowerCase())
-              case "not-contains":
-                return !(k as string).toLowerCase().includes(p.value.toLowerCase())
-              case "not-ends-with":
-                return !(k as string).toLowerCase().endsWith(p.value.toLowerCase())
-              case "not-starts-with":
-                return !(k as string).toLowerCase().startsWith(p.value.toLowerCase())
-              case "not-eq":
-                return !compare(k, p.value)
-              case "eq":
-              case undefined:
-                return compare(k, p.value)
-            }
-          })
-        ? Option.some(x as unknown as NE)
-        : Option.none()
-      : filter
-          .where
-          .every((p) => {
-            const k = get(x, p.key)
-            switch (p.t) {
-              case "in":
-                return p.value.includes(k)
-              case "not-in":
-                return !p.value.includes(k)
-              case "lt":
-                return lowerThan(k, p.value)
-              case "lte":
-                return lowerThanExclusive(k, p.value)
-              case "gt":
-                return greaterThan(k, p.value)
-              case "gte":
-                return greaterThanExclusive(k, p.value)
-              case "includes":
-                return (k as Array<string>).includes(p.value)
-              case "not-includes":
-                return !(k as Array<string>).includes(p.value)
-              case "contains":
-                return (k as string).toLowerCase().includes(p.value.toLowerCase())
-              case "ends-with":
-                return (k as string).toLowerCase().endsWith(p.value.toLowerCase())
-              case "starts-with":
-                return (k as string).toLowerCase().startsWith(p.value.toLowerCase())
-              case "not-contains":
-                return !(k as string).toLowerCase().includes(p.value.toLowerCase())
-              case "not-ends-with":
-                return !(k as string).toLowerCase().endsWith(p.value.toLowerCase())
-              case "not-starts-with":
-                return !(k as string).toLowerCase().startsWith(p.value.toLowerCase())
-              case "not-eq":
-                return p.key.includes(".-1.")
-                  ? (get(x, p.key.split(".-1.")[0]) as any[])
-                    // TODO: or vs and
-                    .every((_) => !compare(get(_, p.key.split(".-1.")[1]!), p.value))
-                  : !compare(k, p.value)
-              case "eq":
-              case undefined:
-                return p.key.includes(".-1.")
-                  ? (get(x, p.key.split(".-1.")[0]) as any[])
-                    // TODO: or vs and
-                    .some((_) => compare(get(_, p.key.split(".-1.")[1]!), p.value))
-                  : compare(k, p.value)
-            }
-          })
-      ? Option.some(x as unknown as NE)
-      : Option.none()
-}
-
-export function codeFilterJoinSelect<E extends { id: string }, NE>(
-  filter: FilterJoinSelect
-) {
-  return (x: E) =>
-    ReadonlyArray
-      .filterMap(
-        filter
-          .keys,
-        (k) => {
-          const value = get(x, k)
-          // we mimic the behavior of cosmosdb; if the shape in db does not match what we're looking for, we imagine false hit
-          return value
-            ? Option.some(
-              ReadonlyArray.filterMap(value as readonly NE[], (v) =>
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                compare((v as any)[filter.valueKey], filter.value)
-                  ? Option.some({ ...v, _rootId: x.id })
-                  : Option.none())
-            )
-            : Option.none()
-        }
-      )
-      .flatMap((_) => _)
+  return (x: E) => codeFilter3_(filter.build(), x) ? Option.some(x as unknown as NE) : Option.none()
 }
 
 export function lowercaseIfString<T>(val: T) {

package/src/services/query/dsl.ts

@@ -251,11 +251,11 @@ export type FilterWheres = {
   <
     TFieldValues extends FieldValues,
     TFieldName extends FieldPath<TFieldValues>,
-    V extends FieldPathValue<TFieldValues, TFieldName>
+    V extends string
   >(
     path: TFieldName,
     op: "startsWith" | "endsWith" | "contains" | "notContains" | "notStartsWith" | "notEndsWith",
-    value: V // only strings?
+    value: V
   ): (
     current: Query<TFieldValues>
   ) => QueryWhere<TFieldValues>
@@ -322,11 +322,11 @@ export type FilterContinuations = {
   <
     TFieldValues extends FieldValues,
     TFieldName extends FieldPath<TFieldValues>,
-    V extends FieldPathValue<TFieldValues, TFieldName>
+    V extends string
   >(
     path: TFieldName,
     op: "startsWith" | "endsWith" | "contains" | "notContains" | "notStartsWith" | "notEndsWith",
-    value: V // only strings?
+    value: V
   ): (
     current: QueryWhere<TFieldValues>
   ) => QueryWhere<TFieldValues>