@effect-app/infra 0.118.0 → 0.120.0

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/index.ts

@@ -15,7 +15,6 @@ import { StoreMaker } from "./service.js"
  */
 export function StoreMakerLive(config: Config<StorageConfig>) {
   return config
-    .config
     .flatMap((cfg) => {
       const storageUrl = cfg.url.value
       if (storageUrl.startsWith("mem://")) {

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 })[]>

package/_src/services/Store/utils.ts

@@ -5,6 +5,7 @@ import { OptimisticConcurrencyException } from "../../errors.js"
 import type { Filter, FilterJoinSelect, PersistenceModelType, SupportedValues2 } from "./service.js"
 
 import objectHash from "object-hash"
+import { codeFilter3_ } from "./codeFilter.js"
 
 export const makeETag = <E extends PersistenceModelType<Id>, Id extends string>(
   { _etag, ...e }: E
@@ -38,7 +39,9 @@ export const makeUpdateETag =
 
 export function codeFilter<E extends { id: string }, NE extends E>(filter: Filter<NE>) {
   return (x: E) =>
-    filter.type === "startsWith"
+    filter.type === "new-kid"
+      ? codeFilter3_(filter.build(), x) ? Option(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(x as unknown as NE)
@@ -184,38 +187,38 @@ export function codeFilterJoinSelect<E extends { id: string }, NE>(
       .flatMap((_) => _)
 }
 
-function lowercaseIfString<T>(val: T) {
+export function lowercaseIfString<T>(val: T) {
   if (typeof val === "string") {
     return val.toLowerCase()
   }
   return val
 }
 
-function compareCaseInsensitive(valA: unknown, valB: unknown) {
+export function compareCaseInsensitive(valA: unknown, valB: unknown) {
   return typeof valB === "string" && typeof valA === "string"
     ? valA.toLowerCase() === valB.toLowerCase()
     : valA === valB
 }
 
-function ltCaseInsensitive(valA: SupportedValues2, valB: SupportedValues2) {
+export function ltCaseInsensitive(valA: SupportedValues2, valB: SupportedValues2) {
   return typeof valB === "string" && typeof valA === "string"
     ? valA.toLowerCase() < valB.toLowerCase()
     : valA < valB
 }
 
-function lteCaseInsensitive(valA: SupportedValues2, valB: SupportedValues2) {
+export function lteCaseInsensitive(valA: SupportedValues2, valB: SupportedValues2) {
   return typeof valB === "string" && typeof valA === "string"
     ? valA.toLowerCase() <= valB.toLowerCase()
     : valA <= valB
 }
 
-function gtCaseInsensitive(valA: SupportedValues2, valB: SupportedValues2) {
+export function gtCaseInsensitive(valA: SupportedValues2, valB: SupportedValues2) {
   return typeof valB === "string" && typeof valA === "string"
     ? valA.toLowerCase() > valB.toLowerCase()
     : valA > valB
 }
 
-function gteCaseInsensitive(valA: SupportedValues2, valB: SupportedValues2) {
+export function gteCaseInsensitive(valA: SupportedValues2, valB: SupportedValues2) {
   return typeof valB === "string" && typeof valA === "string"
     ? valA.toLowerCase() >= valB.toLowerCase()
     : valA >= valB

package/dist/services/Emailer/Sendgrid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Sendgrid.d.ts","sourceRoot":"","sources":["../../../_src/services/Emailer/Sendgrid.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4CAA4C,CAAA;AAG3E,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,KAAK,EAAE,QAAQ,EAAwB,cAAc,EAAE,MAAM,cAAc,CAAA;;;;;AAoDlF,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC,0FAK1D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,OAAO,SAUpC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMnB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,SAAS,WAO1C"}
+{"version":3,"file":"Sendgrid.d.ts","sourceRoot":"","sources":["../../../_src/services/Emailer/Sendgrid.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4CAA4C,CAAA;AAG3E,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,KAAK,EAAE,QAAQ,EAAwB,cAAc,EAAE,MAAM,cAAc,CAAA;;;;;AAoDlF,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC,0FAI1D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,OAAO,SAUpC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMnB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,SAAS,WAO1C"}

package/dist/services/Emailer/Sendgrid.js

@@ -42,7 +42,7 @@ const makeLiveSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subje
  * @tsplus static Emailer.Ops LiveSendgrid
  */
 export function LiveSendgrid(config) {
-    return tsplus_module_3.effect(Emailer)(tsplus_module_2.flatMap(tsplus_module_2.config(config), makeLiveSendgrid));
+    return tsplus_module_3.effect(Emailer)(tsplus_module_2.flatMap(config, makeLiveSendgrid));
 }
 /**
  * @hidden
@@ -98,4 +98,4 @@ function renderMailData(md) {
     }
     return md.email;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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