@effect-app/infra 0.210.10 → 0.211.0

package/src/filter.ts

@@ -1,420 +0,0 @@
-import type { FieldValues } from "./filter/types/fields.js"
-import type { FieldPath, FieldPathValue } from "./filter/types/path/eager.js"
-import type { SupportedValues, Where } from "./services/Store.js"
-
-/**
- * the function defaults to "eq", but has additional properties for notEq, in and notIn
- */
-export interface WhereFilter<TFieldValues extends FieldValues>
-  extends ReturnType<typeof makeWhereFilter_<TFieldValues>>
-{}
-export function makeWhereFilter<TFieldValues extends FieldValues>() {
-  const f = makeWhereFilter_<TFieldValues>()
-  return f as WhereFilter<TFieldValues>
-}
-
-function makeHelpers<TFieldValues extends FieldValues>() {
-  const helpers = makeHelpers_<TFieldValues>()
-  return helpers as WhereHelpers<TFieldValues>
-}
-
-export interface WhereHelpers<TFieldValues extends FieldValues> extends ReturnType<typeof makeHelpers_<TFieldValues>> {}
-
-function makeHelpers_<TFieldValues extends FieldValues>() {
-  type Paths = FieldPath<TFieldValues>
-  type Value<TFieldName extends Paths> = FieldPathValue<TFieldValues, TFieldName>
-
-  return {
-    in<TFieldName extends Paths, V extends Value<TFieldName>>(
-      this: void,
-      path: TFieldName,
-      value: readonly V[]
-    ) {
-      return { key: path, value, t: "in" as const }
-    },
-    notIn<TFieldName extends Paths, V extends Value<TFieldName>>(
-      this: void,
-      path: TFieldName,
-      value: readonly V[]
-    ) {
-      return { key: path, value, t: "not-in" as const }
-    },
-    includes<TFieldName extends Paths, V extends Value<TFieldName>>(
-      this: void,
-      path: TFieldName,
-      value: V
-    ) {
-      return { key: path, value, t: "includes" as const }
-    },
-    notIncludes<TFieldName extends Paths, V extends Value<TFieldName>>(
-      this: void,
-      path: TFieldName,
-      value: V
-    ) {
-      return { key: path, value, t: "not-includes" as const }
-    },
-    eq<TFieldName extends Paths, V extends Value<TFieldName>>(
-      this: void,
-      path: TFieldName,
-      value: V
-    ) {
-      return { key: path, value, t: "eq" as const }
-    },
-    notEq<TFieldName extends Paths, V extends Value<TFieldName>>(
-      this: void,
-      path: TFieldName,
-      value: V
-    ) {
-      return { key: path, value, t: "not-eq" as const }
-    },
-    gt<TFieldName extends Paths, V extends Value<TFieldName>>(
-      this: void,
-      path: TFieldName,
-      value: V
-    ) {
-      return { key: path, value, t: "gt" as const }
-    },
-    gte<TFieldName extends Paths, V extends Value<TFieldName>>(
-      this: void,
-      path: TFieldName,
-      value: V
-    ) {
-      return { key: path, value, t: "gte" as const }
-    },
-    lt<TFieldName extends Paths, V extends Value<TFieldName>>(
-      this: void,
-      path: TFieldName,
-      value: V
-    ) {
-      return { key: path, value, t: "lt" as const }
-    },
-    lte<TFieldName extends Paths, V extends Value<TFieldName>>(
-      this: void,
-      path: TFieldName,
-      value: V
-    ) {
-      return { key: path, value, t: "lte" as const }
-    }
-  } satisfies Record<string, (...args: any[]) => Where>
-}
-
-function makeWhereFilter_<TFieldValues extends FieldValues>() {
-  const helpers = makeHelpers<TFieldValues>()
-  const f = Object.assign(helpers.eq, helpers)
-  return f
-}
-
-export type WhereValue<
-  T extends
-    | "eq"
-    | "not-eq"
-    | "lt"
-    | "gt"
-    | "lte"
-    | "gte"
-    | "starts-with"
-    | "ends-with"
-    | "contains"
-    | "not-starts-with"
-    | "not-ends-with"
-    | "not-contains"
-    | "in"
-    | "not-in"
-    | "includes"
-    | "not-includes",
-  A, // extends SupportedValues,
-  V extends A = A
-> = { t: T; v: V }
-
-export type WhereIn<T extends "in" | "not-in", V, Values extends readonly V[] = readonly V[]> = {
-  t: T
-  v: Values
-}
-
-export function $in<A extends SupportedValues, Values extends readonly A[]>(
-  _: A,
-  ...v: Values
-): WhereIn<"in", A, Values> {
-  return $$in(v)
-}
-
-export function $notIn<A extends SupportedValues, Values extends readonly A[]>(
-  _: A,
-  ...v: Values
-): WhereIn<"not-in", A, Values> {
-  return $$notIn(v)
-}
-
-export function $is<A, V extends A>(_: A, v: V): WhereValue<"eq", A, V> {
-  return $$is(v)
-}
-
-export function $includes<A extends readonly any[], V extends A[number]>(_: A, v: V): WhereValue<"includes", A, V> {
-  return $$includes(v)
-}
-
-export function $notIncludes<A extends readonly any[], V extends A[number]>(
-  _: A,
-  v: V
-): WhereValue<"not-includes", A, V> {
-  return $$notIncludes(v)
-}
-
-export function $isnt<A, V extends A>(_: A, v: V): WhereValue<"not-eq", A, V> {
-  return $$isnt(v)
-}
-
-export function $gt<A, V extends A>(_: A, v: V): WhereValue<"gt", A, V> {
-  return $$gt(v)
-}
-
-export function $gte<A, V extends A>(_: A, v: V): WhereValue<"gte", A, V> {
-  return $$gte(v)
-}
-
-export function $lt<A, V extends A>(_: A, v: V): WhereValue<"lt", A, V> {
-  return $$lt(v)
-}
-
-export function $lte<A, V extends A>(_: A, v: V): WhereValue<"lte", A, V> {
-  return $$lte(v)
-}
-
-function $is__<V extends A, A>(v: V) {
-  return (_: A) => $is(_, v)
-}
-
-function $isnt__<V extends A, A>(v: V) {
-  return (_: A) => $isnt(_, v)
-}
-
-function $includes__<V extends A[number], A extends readonly any[]>(v: V) {
-  return (_: A) => $includes(_, v)
-}
-
-function $notIncludes__<V extends A[number], A extends readonly any[]>(v: V) {
-  return (_: A) => $notIncludes(_, v)
-}
-
-function $lt__<V extends A, A>(v: V) {
-  return (_: A) => $lt(_, v)
-}
-
-function $lte__<V extends A, A>(v: V) {
-  return (_: A) => $lte(_, v)
-}
-
-function $gt__<V extends A, A>(v: V) {
-  return (_: A) => $gt(_, v)
-}
-
-function $gte__<V extends A, A>(v: V) {
-  return (_: A) => $gte(_, v)
-}
-
-function $in__<A extends SupportedValues, Values extends readonly A[]>(
-  ...v: Values
-) {
-  return (_: A) => $in(_, ...v)
-}
-
-function $notIn__<A extends SupportedValues, Values extends readonly A[]>(
-  ...v: Values
-) {
-  return (_: A) => $notIn(_, ...v)
-}
-
-function $startsWith__<V extends A, A extends string>(v: V) {
-  return (_: A) => $startsWith(_, v)
-}
-
-function $endsWith__<V extends A, A extends string>(v: V) {
-  return (_: A) => $endsWith(_, v)
-}
-
-function $contains__<V extends A, A extends string>(v: V) {
-  return (_: A) => $contains(_, v)
-}
-
-export const Filters = {
-  is: $is__,
-  isnt: $isnt__,
-  in: $in__,
-  notIn: $notIn__,
-  gt: $gt__,
-  gte: $gte__,
-  lt: $lt__,
-  lte: $lte__,
-  contains: $contains__,
-  endsWith: $endsWith__,
-  startsWith: $startsWith__,
-  includes: $includes__,
-  notIncludes: $notIncludes__
-}
-
-export function $notStartsWith<A extends string, V extends A>(_: A, v: V): WhereValue<"not-starts-with", A, V> {
-  return $$notStartsWith(v)
-}
-
-export function $notEndsWith<A extends string, V extends A>(_: A, v: V): WhereValue<"not-ends-with", A, V> {
-  return $$notEndsWith(v)
-}
-
-export function $notContains<A extends string, V extends A>(_: A, v: V): WhereValue<"not-contains", A, V> {
-  return $$notContains(v)
-}
-
-export function $startsWith<A extends string, V extends A>(_: A, v: V): WhereValue<"starts-with", A, V> {
-  return $$startsWith(v)
-}
-
-export function $endsWith<A extends string, V extends A>(_: A, v: V): WhereValue<"ends-with", A, V> {
-  return $$endsWith(v)
-}
-
-export function $contains<A extends string, V extends A>(_: A, v: V): WhereValue<"contains", A, V> {
-  return $$contains(v)
-}
-
-function $$in<L extends readonly any[]>(v: L) {
-  return { t: "in" as const, v }
-}
-
-function $$notIn<L extends readonly any[]>(v: L) {
-  return { t: "not-in" as const, v }
-}
-function $$is<A>(v: A) {
-  return { t: "eq" as const, v }
-}
-function $$isnt<A>(v: A) {
-  return { t: "not-eq" as const, v }
-}
-function $$includes<A>(v: A) {
-  return { t: "includes" as const, v }
-}
-function $$notIncludes<A>(v: A) {
-  return { t: "not-includes" as const, v }
-}
-
-function $$lt<A>(v: A) {
-  return { t: "lt" as const, v }
-}
-
-function $$lte<A>(v: A) {
-  return { t: "lte" as const, v }
-}
-function $$gt<A>(v: A) {
-  return { t: "gt" as const, v }
-}
-
-function $$gte<A>(v: A) {
-  return { t: "gte" as const, v }
-}
-
-function $$contains<A extends string>(v: A) {
-  return { t: "contains" as const, v }
-}
-function $$startsWith<A extends string>(v: A) {
-  return { t: "starts-with" as const, v }
-}
-function $$endsWith<A extends string>(v: A) {
-  return { t: "ends-with" as const, v }
-}
-
-function $$notContains<A extends string>(v: A) {
-  return { t: "not-contains" as const, v }
-}
-function $$notStartsWith<A extends string>(v: A) {
-  return { t: "not-starts-with" as const, v }
-}
-function $$notEndsWith<A extends string>(v: A) {
-  return { t: "not-ends-with" as const, v }
-}
-
-type ValueType<V> = {
-  t: "in" | "not-in"
-  v: readonly V[]
-} | { t: "eq" | "not-eq"; v: V }
-
-type TType<T> = T extends ValueType<any> ? T["t"] : never
-type VType<T> = T extends ValueType<any> ? T["v"] : never
-
-function f(p: string, b: any) {
-  if (typeof b === "function") b = b(undefined)
-  const obj = typeof b === "object" && b !== null
-  return makeFilter(p, obj ? b.v : b, obj ? b.t ?? "eq" : "eq")
-}
-
-function makeFilter<T extends "in" | "not-in" | "eq" | "not-eq">(path: string, value: any, t: T) {
-  return { key: path, t, value }
-}
-
-type FIL<S, K extends string, T extends "in" | "not-in" | "eq" | "not-eq", V> = {
-  key: K
-  t: T
-  value: V
-  readonly S: S
-}
-
-export function makeFilters<T extends FieldValues>() {
-  type Paths = FieldPath<T>
-  type Value<TFieldName extends Paths> = FieldPathValue<T, TFieldName>
-
-  function test<
-    TFieldName extends Paths,
-    A extends Value<TFieldName>,
-    Val
-  >(
-    path: TFieldName,
-    value: (v: A) => Val
-  ): FIL<T, string, TType<Val>, VType<Val>>
-  function test<
-    TFieldName extends Paths,
-    A extends Value<TFieldName>
-  >(
-    path: TFieldName,
-    value: A
-  ): FIL<T, string, "eq", A>
-  function test(p: string, v: any) {
-    return f(p, v) as any
-  }
-  return test
-}
-
-// export function makeFilter<TFieldValues extends FieldValues>() {
-//   const f = makeFilter_<TFieldValues>()
-//   return f as WhereFilterHelper<TFieldValues>
-// }
-
-// export interface WhereFilterHelper<TFieldValues extends FieldValues> extends ReturnType<typeof makeFilter_<TFieldValues>> {}
-
-// function makeFilter_<TFieldValues extends FieldValues>() {
-//   function eq<TFieldName extends FieldPath<TFieldValues>, V extends FieldPathValue<TFieldValues, TFieldName>>(
-//     path: TFieldName,
-//     value: V
-//   ) {
-//     return { key: path, value, t: "eq" as const }
-//   }
-//   const f = Object.assign(eq satisfies (...args: any[]) => Where, {
-//     in<TFieldName extends FieldPath<TFieldValues>, V extends FieldPathValue<TFieldValues, TFieldName>>(
-//       path: TFieldName,
-//       value: readonly V[]
-//     ) {
-//       return { key: path, value, t: "in" as const }
-//     },
-//     notIn<TFieldName extends FieldPath<TFieldValues>, V extends FieldPathValue<TFieldValues, TFieldName>>(
-//       path: TFieldName,
-//       value: readonly V[]
-//     ) {
-//       return { key: path, value, t: "not-in" as const }
-//     },
-//     eq,
-//     notEq<TFieldName extends FieldPath<TFieldValues>, V extends FieldPathValue<TFieldValues, TFieldName>>(
-//       path: TFieldName,
-//       value: V
-//     ) {
-//       return { key: path, value, t: "not-eq" as const }
-//     }
-//   } satisfies Record<string, (...args: any[]) => Where>)
-//   return f
-// }

package/src/services/Store/Cosmos.test.ts

@@ -1,94 +0,0 @@
-import type { StoreWhereFilter, Where } from "@effect-app/infra/services/Store"
-import { Filters, makeFilters } from "../../filter.js"
-import { buildWhereCosmosQuery } from "./Cosmos/query.js"
-
-const f_ = makeFilters<Something>()
-export type SomethingWhereFilter = typeof f_
-
-export function makeSomethingFilter_(filter: (f: SomethingWhereFilter) => StoreWhereFilter) {
-  return filter(f_)
-}
-
-export function somethingsWhere(
-  makeWhere: (
-    f: SomethingWhereFilter
-  ) => Where | [Where, ...Where[]],
-  mode?: "or" | "and"
-) {
-  return makeSomethingFilter_((f) => {
-    const m = makeWhere ? makeWhere(f) : []
-    return ({
-      mode,
-      where: (Array.isArray(m) ? m as unknown as [Where, ...Where[]] : [m]) as readonly [Where, ...Where[]]
-    })
-  })
-}
-
-type SomethingElse = {
-  a: string
-  b: number
-}
-
-type Something = {
-  a: number
-  id: string
-  b: string
-  c: readonly string[]
-  d: readonly SomethingElse[]
-}
-
-test("works", () => {
-  expect(buildWhereCosmosQuery(
-    somethingsWhere((_) => _("b", (_) => "b2")),
-    "Somethings",
-    "importedMarkerId",
-    {},
-    undefined,
-    10
-  ))
-    .toEqual({
-      "parameters": [
-        {
-          "name": "@id",
-          "value": "importedMarkerId"
-        },
-        {
-          "name": "@v0",
-          "value": "b2"
-        }
-      ],
-      "query": `
-    SELECT f
-    FROM Somethings f
-    
-    WHERE f.id != @id AND f.b = @v0
-    OFFSET 0 LIMIT 10`
-    })
-
-  expect(buildWhereCosmosQuery(
-    somethingsWhere((_) => _("d.-1.a", Filters.isnt("a2"))),
-    "Somethings",
-    "importedMarkerId",
-    {},
-    undefined,
-    10
-  ))
-    .toEqual({
-      "parameters": [
-        {
-          "name": "@id",
-          "value": "importedMarkerId"
-        },
-        {
-          "name": "@v0",
-          "value": "a2"
-        }
-      ],
-      "query": `
-    SELECT f
-    FROM Somethings f
-    JOIN d IN f.d
-    WHERE f.id != @id AND d.a <> @v0
-    OFFSET 0 LIMIT 10`
-    })
-})

package/src/services/Store/codeFilter.test.ts

@@ -1,166 +0,0 @@
-import type { StoreWhereFilter, Where } from "@effect-app/infra/services/Store"
-import { ReadonlyArray } from "effect-app"
-import { Filters, makeFilters } from "../../filter.js"
-import { codeFilter } from "./utils.js"
-
-const somethings = [
-  { a: 1, b: "b", c: ["c"], d: [{ a: "a2", b: 1 }, { a: "a", b: 1 }], id: "1" },
-  { a: 2, b: "b2", c: ["c2"], d: [{ a: "a4", b: 2 }, { a: "a5", b: 2 }], id: "2" }
-] satisfies readonly Something[]
-
-const f_ = makeFilters<Something>()
-export type SomethingWhereFilter = typeof f_
-
-export function makeSomethingFilter_(filter: (f: SomethingWhereFilter) => StoreWhereFilter) {
-  return filter(f_)
-}
-
-export function somethingsWhere(
-  makeWhere: (
-    f: SomethingWhereFilter
-  ) => Where | [Where, ...Where[]],
-  mode?: "or" | "and"
-) {
-  return makeSomethingFilter_((f) => {
-    const m = makeWhere ? makeWhere(f) : []
-    return ({
-      mode,
-      where: (Array.isArray(m) ? m as unknown as [Where, ...Where[]] : [m]) as readonly [Where, ...Where[]]
-    })
-  })
-}
-
-type SomethingElse = {
-  a: string
-  b: number
-}
-
-type Something = {
-  a: number
-  id: string
-  b: string
-  c: readonly string[]
-  d: readonly SomethingElse[]
-}
-
-test("works", () => {
-  expect(
-    ReadonlyArray.filterMap(
-      somethings,
-      codeFilter(
-        somethingsWhere((_) => _("b", (_) => "b2"))
-      )
-    )
-  )
-    .toEqual([somethings[1]])
-
-  expect(
-    ReadonlyArray.filterMap(
-      somethings,
-      codeFilter(
-        somethingsWhere((_) => _("b", Filters.contains("b")))
-      )
-    )
-  )
-    .toEqual([somethings[0], somethings[1]])
-
-  expect(
-    ReadonlyArray.filterMap(
-      somethings,
-      codeFilter(
-        somethingsWhere((_) => _("b", Filters.contains("2")))
-      )
-    )
-  )
-    .toEqual([somethings[1]])
-
-  expect(
-    ReadonlyArray.filterMap(
-      somethings,
-      codeFilter(
-        somethingsWhere((_) => _("b", Filters.endsWith("b")))
-      )
-    )
-  )
-    .toEqual([somethings[0]])
-
-  expect(
-    ReadonlyArray.filterMap(
-      somethings,
-      codeFilter(
-        somethingsWhere((_) => _("b", Filters.endsWith("2")))
-      )
-    )
-  )
-    .toEqual([somethings[1]])
-
-  expect(
-    ReadonlyArray.filterMap(
-      somethings,
-      codeFilter(
-        somethingsWhere((_) => _("b", Filters.startsWith("b")))
-      )
-    )
-  )
-    .toEqual([somethings[0], somethings[1]])
-
-  expect(
-    ReadonlyArray.filterMap(
-      somethings,
-      codeFilter(
-        somethingsWhere((_) => _("b", Filters.startsWith("2")))
-      )
-    )
-  )
-    .toEqual([])
-
-  expect(
-    ReadonlyArray.filterMap(
-      somethings,
-      codeFilter(
-        somethingsWhere((_) => _("b", (_) => "b"))
-      )
-    )
-  )
-    .toEqual([somethings[0]])
-
-  expect(
-    ReadonlyArray.filterMap(
-      somethings,
-      codeFilter(
-        somethingsWhere((_) => _("c", Filters.includes("c")))
-      )
-    )
-  )
-    .toEqual([somethings[0]])
-
-  expect(
-    ReadonlyArray.filterMap(
-      somethings,
-      codeFilter(
-        somethingsWhere((_) => _("d.-1.a", (_) => "a5"))
-      )
-    )
-  )
-    .toEqual([somethings[1]])
-
-  expect(
-    ReadonlyArray.filterMap(
-      somethings,
-      codeFilter(
-        somethingsWhere((_) => _("d.-1.a", (_) => "a"))
-      )
-    )
-  )
-    .toEqual([somethings[0]])
-
-  expect(
-    ReadonlyArray.filterMap(
-      somethings,
-      codeFilter(
-        somethingsWhere((_) => _("d.-1.a", Filters.isnt("a")))
-      )
-    )
-  )
-    .toEqual([somethings[1]])
-})