@effect-app/infra 0.117.0 → 0.119.0

package/_src/services/Store/filterApi/proxy.ts

@@ -0,0 +1,109 @@
+import type { FieldValues } from "../../../filter/types.js"
+import type { FieldPath } from "../../../filter/types/path/eager.js"
+
+type NullOrUndefined<T, Fallback> = null extends T ? null : undefined extends T ? null : Fallback
+
+export type InOps =
+  | "in"
+  | "notIn"
+
+export type OtherOps =
+  | "endsWith"
+  | "startsWith"
+  | "notEndsWith"
+  | "notStartsWith"
+  | "contains"
+  | "notContains"
+  | "includes"
+  | "notIncludes"
+  | "eq"
+  | "neq"
+  | "gt"
+  | "gte"
+  | "lt"
+  | "lte"
+
+// TODO: includes | notIncludes
+export type Ops = OtherOps | InOps
+type F<T extends FieldValues> = {
+  path: FieldPath<T>
+  op: OtherOps
+  value: string
+}
+
+type FIn<T extends FieldValues> = {
+  op: InOps
+  path: FieldPath<T>
+  value: readonly string[]
+}
+
+type G<T extends FieldValues, Val> = {
+  (value: Val): F<T>
+  startsWith: (value: string) => F<T>
+  notStartsWith: (value: string) => F<T>
+  endsWith: (value: string) => F<T>
+  notEndsWith: (value: string) => F<T>
+  contains: (value: string) => F<T>
+  notContains: (value: string) => F<T>
+  includes: (value: string) => F<T>
+  notIncludes: (value: string) => F<T>
+  in: (...value: readonly Val[]) => FIn<T>
+  notIn: (...value: readonly Val[]) => FIn<T>
+  eq: (value: Val) => F<T>
+  neq: (value: Val) => F<T>
+  gt: (value: Val) => F<T>
+  gte: (value: Val) => F<T>
+  lt: (value: Val) => F<T>
+  lte: (value: Val) => F<T>
+}
+
+export type Filter<T extends FieldValues, Ext = never> = {
+  [K in keyof T]-?: [T[K]] extends [Record<any, any> | undefined | null]
+    ? Filter<T[K], NullOrUndefined<T[K], Ext>> & G<T, T[K] | Ext>
+    : [T[K]] extends [Record<any, any>] ? Filter<T[K], NullOrUndefined<T[K], Ext>> & G<T, T[K] | Ext>
+    : G<T, T[K] | Ext>
+}
+const ops: Ops[] = [
+  "contains",
+  "startsWith",
+  "endsWith",
+  "notContains",
+  "notStartsWith",
+  "notEndsWith",
+  "in",
+  "notIn",
+  "eq",
+  "neq",
+  "gte",
+  "gt",
+  "lt",
+  "lte"
+]
+export const makeProxy = (parentProp?: string): any =>
+  new Proxy(
+    Object.assign(() => {}, {
+      _proxies: {} as Record<string, any>
+    }),
+    {
+      apply(_target, _thisArg, argArray) {
+        return ({ op: "eq", value: argArray[0], path: parentProp })
+      },
+      get(target, prop) {
+        if (typeof prop !== "string") return undefined
+        if (target._proxies[prop]) {
+          return target._proxies[prop]
+        }
+
+        if (ops.includes(prop as any)) {
+          return (value: any) => ({ op: prop, path: parentProp, value })
+        }
+        let fullProp = prop
+        if (parentProp) {
+          fullProp = `${parentProp}.${prop}`
+        }
+        const p = makeProxy(fullProp)
+        target._proxies[prop] = p
+        return p
+      }
+    }
+  )

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

@@ -0,0 +1,256 @@
+import type { FieldValues } from "../../../filter/types.js"
+import type { FieldPath, FieldPathValue } from "../../../filter/types/path/eager.js"
+import type { Filter, Ops } from "./proxy.js"
+import { makeProxy } from "./proxy.js"
+
+export type FilterScopes = {
+  t: "or-scope"
+  result: FilterResult[]
+} | {
+  t: "and-scope"
+  result: FilterResult[]
+} | {
+  t: "where-scope"
+  result: FilterResult[]
+}
+
+export type FilterR = {
+  op: Ops
+
+  path: string
+  value: string // ToDO: Value[]
+}
+
+export type FilterResult =
+  | {
+    t: "where"
+  } & FilterR
+  | {
+    t: "or"
+  } & FilterR
+  | {
+    t: "and"
+  } & FilterR
+  | FilterScopes
+
+export const print = (state: readonly FilterResult[]) => {
+  let s = ""
+  let l = 0
+  const printN = (n: number) => {
+    return n === 0 ? "" : ReadonlyArray.range(1, n).map(() => "  ").join("")
+  }
+  for (const e of state) {
+    switch (e.t) {
+      case "where":
+        s += `${e.path} ${e.op} ${e.value}`
+        break
+      case "or":
+        s += ` OR ${e.path} ${e.op} ${e.value}`
+        break
+      case "and":
+        s += ` AND ${e.path} ${e.op} ${e.value}`
+        break
+      case "or-scope": {
+        ;++l
+        s += ` OR (\n${printN(l + 1)}${print(e.result)}\n${printN(l)})`
+        ;--l
+        break
+      }
+      case "and-scope": {
+        ;++l
+        s += ` AND (\n${printN(l + 1)}${print(e.result)}\n${printN(l)})`
+        ;--l
+
+        break
+      }
+      case "where-scope": {
+        // ;++l
+        s += `(\n${printN(l + 1)}${print(e.result)}\n)`
+        // ;--l
+        break
+      }
+    }
+  }
+  return s
+}
+
+export const makeFilter = <TFieldValues extends FieldValues>() => {
+  // const recursive = {}
+  // const and = Object.assign(() => {}, recursive)
+  // const or = Object.assign(() => {}, recursive)
+  // const where = Object.assign(() => {}, recursive)
+  // recursive.and = and
+  // recursive.or = or
+  // recursive.where = where
+  const state: FilterResult[] = []
+  let current = state
+  const where = (...args: any[]) => {
+    if (typeof args[0] === "function") {
+      const mine: any[] = []
+      const previous = current
+      current = mine
+      const r = args[0](all)
+      current = previous
+      current.push({ t: "where-scope", result: mine })
+      return r
+    }
+    if (args.length === 1) {
+      current.push({ t: "where", ...args[0] })
+      return all
+    }
+    current.push({
+      t: "where",
+      op: args.length === 2 ? "eq" : args[1],
+      path: args[0],
+      value: args[args.length - 1]
+    })
+    return all
+  }
+  const and = (...args: any[]) => {
+    if (typeof args[0] === "function") {
+      const mine: any[] = []
+      const previous = current
+      current = mine
+      const r = args[0](all)
+      current = previous
+      current.push({ t: "and-scope", result: mine })
+      return r
+    }
+    if (args.length === 1) {
+      current.push({ t: "and", ...args[0] })
+      return all
+    }
+    current.push({
+      t: "and",
+      op: args.length === 2 ? "eq" : args[1],
+      path: args[0],
+      value: args[args.length - 1]
+    })
+    return all
+  }
+  const or = (...args: any[]) => {
+    if (typeof args[0] === "function") {
+      const mine: any[] = []
+      const previous = current
+      current = mine
+      const r = args[0](all)
+      current = previous
+      current.push({ t: "or-scope", result: mine })
+      return r
+    }
+    if (args.length === 1) {
+      current.push({ t: "or", ...args[0] })
+      return all
+    }
+    current.push({ t: "or", op: args.length === 2 ? "eq" : args[1], path: args[0], value: args[args.length - 1] })
+    return all
+  }
+  const fields = makeProxy() as Filter<TFieldValues>
+  const all = Object.assign(where, {
+    type: "new-kid",
+    and,
+    or,
+    build() {
+      return state
+    }
+  })
+  return { all, fields }
+}
+
+export const QueryBuilder = {
+  make: <TFieldValues extends FieldValues>(): (
+    fn: (f: FilterTest<TFieldValues>, fields: Filter<TFieldValues>) => QueryBuilder<TFieldValues>
+  ) => QueryBuilder<TFieldValues> => {
+    type F = ReturnType<typeof makeFilter<TFieldValues>>
+    return (
+      f: (
+        n: F["all"],
+        f: F["fields"]
+      ) => QueryBuilder<TFieldValues>
+    ) => {
+      const fil = makeFilter<TFieldValues>()
+      return f(fil.all, fil.fields)
+    }
+  }
+}
+
+export type Initial<TFieldValues extends FieldValues> = {
+  where: FilterTest<TFieldValues>
+  build(): FilterResult[]
+}
+
+export type Filts<TFieldValues extends FieldValues> = {
+  <
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(
+    path: TFieldName,
+    value: V
+  ): QueryBuilder<TFieldValues>
+  <
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(
+    path: TFieldName,
+    op: "neq",
+    value: V
+  ): QueryBuilder<TFieldValues>
+  <
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(
+    path: TFieldName,
+    op: "gt" | "gte" | "lt" | "lte",
+    value: V // only numbers?
+  ): QueryBuilder<TFieldValues>
+  <
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(
+    path: TFieldName,
+    op: "startsWith" | "endsWith" | "contains" | "notContains" | "notStartsWith" | "notEndsWith",
+    value: V // only strings?
+  ): QueryBuilder<TFieldValues>
+  <
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(
+    path: TFieldName,
+    op: "in" | "notIn",
+    value: readonly V[]
+  ): QueryBuilder<TFieldValues>
+}
+
+// type Filter<TFieldValues extends FieldValues> = {
+//   (
+//     fb: (f: Filts<TFieldValues>) => QueryBuilder<TFieldValues>
+//   ): QueryBuilder<TFieldValues>
+// } & Filts<TFieldValues>
+
+export type FilterTest<TFieldValues extends FieldValues> = {
+  (
+    fb: (f: Filts<TFieldValues> & Initial<TFieldValues>) => QueryBuilder<TFieldValues>
+  ): QueryBuilder<TFieldValues>
+  <
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(f: {
+    path: TFieldName
+    op: Ops
+    value: V
+  }): QueryBuilder<TFieldValues>
+} & Filts<TFieldValues>
+// const not = <A extends string>(s: A) => `!${s}`
+
+// type FilterGroup<TFieldValues extends FieldValues> = (
+//   fb: (f: QueryBuilder<TFieldValues>) => QueryBuilder<TFieldValues>
+// ) => QueryBuilder<TFieldValues>
+
+export interface QueryBuilder<TFieldValues extends FieldValues> {
+  type: "new-kid"
+  // TODO: as overloads?
+  and: FilterTest<TFieldValues>
+  or: FilterTest<TFieldValues>
+  build(): FilterResult[]
+  // where: <Filters extends Record<TFieldName extends FieldPath<TFieldValues>, V extends Value< FieldPathValue<TFieldValues, TFieldName>>>(filter: Filters) => QueryBuilder<TFieldValues>
+}

package/_src/services/Store/filterApi.test.ts

@@ -0,0 +1,263 @@
+import { codeFilter3 } from "./codeFilter.js"
+import { buildWhereCosmosQuery3 } from "./Cosmos/query.js"
+import { print, QueryBuilder } from "./filterApi/query.js"
+
+const MyEntity = {
+  query: QueryBuilder
+    .make<MyEntity>()
+}
+
+const removeWhitespace = (a: string) => a.replaceAll(/\s+/g, " ").replaceAll(/^\s+/g, "").replaceAll(/\s+$/g, "")
+
+interface MyEntity {
+  id: string
+  name: string
+  bio: string | null
+  isActive: boolean
+  state: { _tag: "a"; val: number } | { _tag: "b"; val: string } | { _tag: "c"; noVal: boolean }
+  roles: readonly string[]
+  tag: "a" | "b" | "c"
+  age?: number
+  something: {
+    id: number
+    name: string
+  } | null
+}
+
+describe("works", () => {
+  const f = MyEntity.query((where, f) =>
+    where(f.something.id.eq(1))
+      .and(() =>
+        where(f.something.name.startsWith("a")) // or would we do "like", "a%"?
+          .or(f.tag.in("a", "b"))
+          .or(() =>
+            where(f.name.neq("Alfredo"))
+              .and(f.tag("c"))
+          )
+      )
+      // .and(f.state._tag("a"))
+      .and("state._tag", "a")
+      .and(f.isActive(true))
+      .and(f.age.gte(12))
+  )
+
+  const s = f.build()
+  console.log(JSON.stringify(s, undefined, 2))
+  it("print", () =>
+    expect(print(s)).toBe(
+      `something.id eq 1 AND (
+    something.name startsWith a OR tag in a OR (
+    name neq Alfredo AND tag eq c
+  )
+  ) AND isActive eq true AND age gte 12`
+    ))
+  const values: MyEntity[] = [{
+    id: "1",
+    name: "Patrick",
+    bio: "something",
+    age: 13,
+    isActive: true,
+    state: { _tag: "a", val: 1 },
+    roles: ["admin"],
+    tag: "c",
+    something: { id: 1, name: "abc" }
+  }, {
+    id: "1",
+    name: "Patrick",
+    bio: "something",
+    age: 11,
+    isActive: true,
+    state: { _tag: "b", val: "2" },
+    roles: ["admin"],
+    tag: "a",
+    something: { id: 1, name: "abc" }
+  }]
+
+  it("print codef", () => {
+    expect(values.filter(codeFilter3(s))).toStrictEqual([values[0]])
+  })
+
+  it("codeFilter1", () => {
+    expect(values.filter(codeFilter3(s))).toStrictEqual([values[0]])
+  })
+  it("codeFilter2", () => {
+    expect(values.filter(
+      codeFilter3(
+        MyEntity
+          .query((where, f) =>
+            where(f.something.id.eq(0))
+              .and(() =>
+                where(f.something.name.startsWith("a"))
+                  .or(f.tag.in("a", "b"))
+              )
+          )
+          .build()
+      )
+    ))
+      .toStrictEqual([])
+
+    expect(values.filter(
+      codeFilter3(
+        MyEntity
+          .query((where, f) => where(f.something.id.eq(0)))
+          .build()
+      )
+    ))
+      .toStrictEqual([])
+
+    expect(values.filter(
+      codeFilter3(
+        MyEntity
+          .query((where, f) => where(f.something.id.eq(1)))
+          .build()
+      )
+    ))
+      .toStrictEqual(values)
+
+    expect(values.filter(
+      codeFilter3(
+        MyEntity
+          .query((where, f) => where(f.age.eq(11)))
+          .build()
+      )
+    ))
+      .toStrictEqual([values[1]])
+  })
+
+  it("cosmos", () => {
+    const r = buildWhereCosmosQuery3(s, "MyEntity", "marker")
+    expect(removeWhitespace(r.query)).toBe(removeWhitespace(`
+        SELECT *
+    FROM MyEntity f
+    WHERE f.id != @id AND f.something.id = @v0 AND (
+    STARTSWITH(f.something.name, @v1, true) OR ARRAY_CONTAINS(@v2, f.tag) OR (
+    LOWER(f.name) <> LOWER(@v3) AND LOWER(f.tag) = LOWER(@v4)
+  )
+  ) AND f.isActive = @v5 AND f.age >= @v6`))
+    expect(r.parameters).toEqual([
+      {
+        "name": "@id",
+        "value": "marker"
+      },
+      {
+        "name": "@v0",
+        "value": 1
+      },
+      {
+        "name": "@v1",
+        "value": "a"
+      },
+      {
+        "name": "@v2",
+        "value": "a"
+      },
+      {
+        "name": "@v3",
+        "value": "Alfredo"
+      },
+      {
+        "name": "@v4",
+        "value": "c"
+      },
+      {
+        "name": "@v5",
+        "value": true
+      },
+      {
+        "name": "@v6",
+        "value": 12
+      }
+    ])
+  })
+})
+
+// ref https://stackoverflow.com/questions/1241142/sql-logic-operator-precedence-and-and-or
+describe("root-or", () => {
+  const f = MyEntity.query((where, f) =>
+    where(() =>
+      where(f.something.id(1))
+        .and(() =>
+          where(f.something.name.startsWith("a")) // or would we do "like", "a%"?
+            .or(f.tag.in("a", "b"))
+            .or(() =>
+              where(f.name.neq("Alfredo"))
+                .and(f.tag("c"))
+            )
+        )
+        .and(f.bio.contains("abc"))
+        .and(f.isActive(true))
+        .and(f.age.gte(12))
+    )
+      .or(f.name.startsWith("C"))
+  )
+
+  const s = f.build()
+  console.log(JSON.stringify(s, undefined, 2))
+
+  it("print", () => {
+    expect(print(s)).toBe(
+      `(
+  something.id eq 1 AND (
+    something.name startsWith a OR tag in a OR (
+    name neq Alfredo AND tag eq c
+  )
+  ) AND bio contains abc AND isActive eq true AND age gte 12
+) OR name startsWith C`
+    )
+  })
+  it("cosmos", () => {
+    const r = buildWhereCosmosQuery3(s, "MyEntity", "marker")
+    expect(removeWhitespace(r.query)).toBe(removeWhitespace(`    SELECT *
+       FROM MyEntity f
+          
+          WHERE f.id != @id AND (
+    f.something.id = @v0 AND (
+      STARTSWITH(f.something.name, @v1, true) OR ARRAY_CONTAINS(@v2, f.tag) OR (
+      LOWER(f.name) <> LOWER(@v3) AND LOWER(f.tag) = LOWER(@v4)
+    )
+    ) AND CONTAINS(f.bio, @v5, true) AND f.isActive = @v6 AND f.age >= @v7
+  ) OR STARTSWITH(f.name, @v8, true) `))
+    expect(r.parameters).toEqual([
+      {
+        "name": "@id",
+        "value": "marker"
+      },
+      {
+        "name": "@v0",
+        "value": 1
+      },
+      {
+        "name": "@v1",
+        "value": "a"
+      },
+      {
+        "name": "@v2",
+        "value": "a"
+      },
+      {
+        "name": "@v3",
+        "value": "Alfredo"
+      },
+      {
+        "name": "@v4",
+        "value": "c"
+      },
+      {
+        "name": "@v5",
+        "value": "abc"
+      },
+      {
+        "name": "@v6",
+        "value": true
+      },
+      {
+        "name": "@v7",
+        "value": 12
+      },
+      {
+        "name": "@v8",
+        "value": "C"
+      }
+    ])
+  })
+})

package/_src/services/Store/service.ts

@@ -4,6 +4,8 @@ import type { Parser, ParserEnv } from "@effect-app/schema/custom/Parser"
 
 import type { These } from "@effect-app/prelude/schema"
 import type { OptimisticConcurrencyException } from "../../errors.js"
+import type { FieldValues } from "../../filter/types.js"
+import type { QueryBuilder } from "./filterApi/query.js"
 
 export type StoreConfig<E> = {
   uniqueKeys?: UniqueKey[]
@@ -50,10 +52,11 @@ export type JoinFindFilter = {
   valueKey: string /* value paths of E[keys][valueKey] */
   value: any /* value path[valueKey] of E */
 }
-export type Filter<E> =
+export type Filter<E extends FieldValues> =
   | JoinFindFilter
   | StoreWhereFilter
   | LegacyFilter<E>
+  | QueryBuilder<E>
 
 export type FilterJoinSelect = {
   type: "filter_join_select"
@@ -62,12 +65,21 @@ export type FilterJoinSelect = {
   value: any /* value path[valueKey] of E */
 }
 
+export interface FilterArgs<PM extends PersistenceModelType<string>, U extends keyof PM = never> {
+  filter?: Filter<PM>
+  select?: readonly U[]
+  limit?: number
+  skip?: number
+}
+
+export type FilterFunc<PM extends PersistenceModelType<string>> = <U extends keyof PM = never>(
+  args: FilterArgs<PM, U>
+) => Effect<never, never, (U extends undefined ? PM : Pick<PM, U>)[]>
+
 export interface Store<PM extends PersistenceModelType<Id>, Id extends string> {
   all: Effect<never, never, PM[]>
-  filter: (
-    filter: Filter<PM>,
-    cursor?: { limit?: number; skip?: number }
-  ) => Effect<never, never, PM[]>
+  filter: FilterFunc<PM>
+  /** @deprecated */
   filterJoinSelect: <T extends object>(
     filter: FilterJoinSelect
   ) => Effect<never, never, (T & { _rootId: string })[]>