@effect-app/infra 0.7.0

package/_src/services/Repository.ts

@@ -0,0 +1,513 @@
+// Update = Must return updated items
+// Modify = Must `set` updated items, and can return anything.
+import type { InvalidStateError, OptimisticConcurrencyException } from "../errors.js"
+import { NotFoundError } from "../errors.js"
+import type { RequestContext } from "../lib/RequestContext.js"
+import { ContextMap} from "../services/Store.js";
+import type { Filter } from "../services/Store.js"
+import type { FixEnv, PureLogT} from "@effect-app/prelude/_ext/Pure";
+import { Pure } from "@effect-app/prelude/_ext/Pure"
+import type { ParserEnv } from "@effect-app/schema/custom/Parser"
+
+/**
+ * @tsplus type Repository
+ */
+export interface Repository<T extends { id: Id }, PM extends { id: string }, Evt, Id extends string, ItemType extends string> {
+  itemType: ItemType
+  find: (id: Id) => Effect<ContextMap | RequestContext, never, Opt<T>>
+  all: Effect<ContextMap, never, Chunk<T>>
+  save: (
+    items: Iterable<T>,
+    events?: Iterable<Evt>
+  ) => Effect<ContextMap | RequestContext, InvalidStateError | OptimisticConcurrencyException, void>
+  utils: {
+    mapReverse: (
+      pm: PM,
+      setEtag: (id: string, eTag: string | undefined) => void
+    ) => unknown, // TODO
+    parse: (a: unknown, env?: ParserEnv | undefined) => T,
+    all: Effect<never, never, Chunk<PM>>,
+    filter: (filter: Filter<PM>, cursor?: { limit?: number, skip?: number}) => Effect<never, never, Chunk<PM>>
+  }
+}
+
+export interface PureDSL<S, S2, W> {
+  get: ReturnType<typeof Pure.get<S>>, set: typeof Pure.set<S2>, log: (...w: W[]) => PureLogT<W>
+}
+
+export const AnyPureDSL: PureDSL<any, any, any> = { get: Pure.get(), set: Pure.set, log: (...evt: any[]) => Pure.logMany(evt) }
+
+/**
+ * @tsplus fluent Repository get
+ */
+export function get<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string
+>(
+  self: Repository<T, PM, Evt, Id, ItemType>,
+  id: Id
+) {
+  return self.find(id).flatMap(_ => _.encaseInEffect(() => new NotFoundError(self.itemType, id)))
+}
+
+/**
+ * @tsplus fluent Repository filter
+ */
+export function filter<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string,
+>(self: Repository<T, PM, Evt, Id, ItemType>, filter: Predicate<T>) {
+  return self.all.map(_ => _.filter(filter))
+}
+
+/**
+ * @tsplus fluent Repository filterAll
+ */
+export function filterAll<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string,
+  S extends T,
+>(self: Repository<T, PM, Evt, Id, ItemType>, map: (items: Chunk<T>) => Chunk<S>) {
+  return self.all.map(map)
+}
+
+
+/**
+ * @tsplus fluent Repository collect
+ */
+export function collect<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string,
+  S extends T,
+>(self: Repository<T, PM, Evt, Id, ItemType>, collect: (item: T) => Opt<S>) {
+  return self.all.map(_ => _.filterMap(collect))
+}
+
+/**
+ * @tsplus getter Repository log
+ */
+export function log<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string
+>(_: Repository<T, PM, Evt, Id, ItemType>) {
+  return (evt: Evt) => AnyPureDSL.log(evt)
+}
+
+/**
+ * TODO: project inside the db.
+ * @tsplus fluent Repository projectEffect
+ */
+export function projectEffect<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string,
+  S,
+  R,
+  E
+>(
+  self: Repository<T, PM, Evt, Id, ItemType>,
+  map: Effect<R, E, { filter?: Filter<PM>; collect: (t: PM) => Opt<S>; limit?: number; skip?: number }>
+) {
+  // TODO: a projection that gets sent to the db instead.
+  return map.flatMap(f =>
+    (f.filter ? self.utils.filter(f.filter, { limit: f.limit, skip: f.skip}) : self.utils.all)
+      .map(_ => _.filterMap(f.collect))
+  )
+}
+
+/**
+ * TODO: project inside the db.
+ * @tsplus fluent Repository project
+ */
+export function project<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string,
+  S,
+>(
+  self: Repository<T, PM, Evt, Id, ItemType>,
+  map: { filter?: Filter<PM>; collect: (t: PM) => Opt<S>; limit?: number; skip?: number }
+) {
+  return self.projectEffect(Effect(map))
+}
+
+
+/**
+ * @tsplus fluent Repository queryEffect
+ */
+export function queryEffect<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string,
+  R,
+  E,
+  S,
+>(
+  self: Repository<T, PM, Evt, Id, ItemType>,
+  // TODO: think about collectPM, collectE, and collect(Parsed)
+  map: Effect<R, E, { filter?: Filter<PM>; collect: (t: T) => Opt<S>; limit?: number; skip?: number }>
+) {
+  return map.flatMap(f =>
+    (f.filter ? self.utils.filter(f.filter, { limit: f.limit, skip: f.skip}) : self.utils.all)
+      .flatMap(items =>
+        Do($ => {
+          const { set } = $(Effect.service(ContextMap))
+          return items.map(_ => self.utils.mapReverse(_, set))
+        })
+      )
+      .map(_ => _.map(_ => self.utils.parse(_)))
+      .map(_ => _.filterMap(f.collect))
+  )
+}
+
+/**
+ * @tsplus fluent Repository queryOneEffect
+ */
+export function queryOneEffect<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string,
+  R,
+  E,
+  S,
+>(
+  self: Repository<T, PM, Evt, Id, ItemType>,
+  // TODO: think about collectPM, collectE, and collect(Parsed)
+  map: Effect<R, E, { filter?: Filter<PM>; collect: (t: T) => Opt<S> }>
+) {
+  return map.flatMap(f =>
+    (f.filter ? self.utils.filter(f.filter, { limit: 1 }) : self.utils.all)
+      .flatMap(items =>
+        Do($ => {
+          const { set } = $(Effect.service(ContextMap))
+          return items.map(_ => self.utils.mapReverse(_, set))
+        })
+      )
+      .map(_ => _.map(_ => self.utils.parse(_)))
+      .flatMap(_ => _.filterMap(f.collect).toNonEmptyArray.encaseInEffect(() => new NotFoundError(self.itemType, JSON.stringify(f.filter))).map(_ => _[0]))
+  )
+}
+
+/**
+ * @tsplus fluent Repository query
+ */
+export function query<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string,
+  S,
+>(
+  self: Repository<T, PM, Evt, Id, ItemType>,
+  // TODO: think about collectPM, collectE, and collect(Parsed)
+  map: { filter?: Filter<PM>; collect: (t: T) => Opt<S>; limit?: number; skip?: number }
+) {
+  return self.queryEffect(Effect(map))
+}
+
+/**
+ * @tsplus fluent Repository queryOne
+ */
+export function queryOne<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string,
+  S,
+>(
+  self: Repository<T, PM, Evt, Id, ItemType>,
+  // TODO: think about collectPM, collectE, and collect(Parsed)
+  map: { filter?: Filter<PM>; collect: (t: T) => Opt<S> }
+) {
+  return self.queryOneEffect(Effect(map))
+}
+
+/**
+ * @tsplus fluent Repository queryAndSavePureEffect
+ */
+export function queryAndSavePureEffect<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string,
+  R,
+  E,
+  S extends T = T,
+>(
+  self: Repository<T, PM, Evt, Id, ItemType>,
+  // TODO: think about collectPM, collectE, and collect(Parsed)
+  map: Effect<R, E, { filter: Filter<PM>; collect: (t: T) => Opt<S>; limit?: number; skip?: number }>
+) {
+  return <R2, A, E2, S2 extends T>(pure: Effect<FixEnv<R2, Evt, Chunk<S>, Iterable<S2>>, E2, A>) =>
+    queryEffect(self, map)
+      .flatMap(_ => self.saveManyWithPure_(_, pure))
+}
+
+/**
+ * @tsplus fluent Repository queryAndSavePure
+ */
+export function queryAndSavePure<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string,
+  S extends T = T,
+>(
+  self: Repository<T, PM, Evt, Id, ItemType>,
+  // TODO: think about collectPM, collectE, and collect(Parsed)
+  map: { filter: Filter<PM>; collect: (t: T) => Opt<S>; limit?: number; skip?: number }
+) {
+  return self.queryAndSavePureEffect(Effect(map))
+}
+
+/**
+ * @tsplus getter Repository saveManyWithPure
+ */
+export function saveManyWithPure<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string
+>(self: Repository<T, PM, Evt, Id, ItemType>) {
+  return <R, A, E, S1 extends T, S2 extends T>(pure: Effect<FixEnv<R, Evt, Chunk<S1>, Iterable<S2>>, E, A>) =>
+    (items: Iterable<S1>) => saveManyWithPure_(self, items, pure)
+}
+
+/**
+ * @tsplus fluent Repository byIdAndSaveWithPure
+ */
+export function byIdAndSaveWithPure<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string
+>(self: Repository<T, PM, Evt, Id, ItemType>, id: Id) {
+  return <R, A, E, S2 extends T>(pure: Effect<FixEnv<R, Evt, T, S2>, E, A>) => get(self, id).flatMap(item => saveWithPure_(self, item, pure))
+}
+
+/**
+ * NOTE: it's not as composable, only useful when the request is simple, and only this part needs request args.
+ * @tsplus getter Repository handleByIdAndSaveWithPure
+ */
+export function handleByIdAndSaveWithPure<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string,
+>(self: Repository<T, PM, Evt, Id, ItemType>) {
+  return <Req extends { id: Id }, Context, R, A, E, S2 extends T>(pure: (req: Req, ctx: Context) => Effect<FixEnv<R, Evt, T, S2>, E, A>) => (req: Req, ctx: Context) => byIdAndSaveWithPure(self, req.id)(pure(req, ctx))
+}
+
+/**
+ * @tsplus fluent Repository saveManyWithPure_
+ */
+export function saveManyWithPure_<
+  Id extends string,
+  R,
+  T extends { id: Id },
+  PM extends { id: string },
+  A,
+  E,
+  Evt,
+  S1 extends T,
+  S2 extends T,
+  ItemType extends string
+>(
+  self: Repository<T, PM, Evt, Id, ItemType>,
+  items: Iterable<S1>,
+  pure: Effect<FixEnv<R, Evt, Chunk<S1>, Iterable<S2>>, E, A>
+) {
+  return saveAllWithEffectInt(
+    self,
+    pure.runTerm(items.toChunk)
+  )
+}
+
+/**
+ * @tsplus fluent Repository saveWithPure_
+ */
+export function saveWithPure_<
+  Id extends string,
+  R,
+  T extends { id: Id },
+  PM extends { id: string },
+  A,
+  E,
+  Evt,
+  S1 extends T,
+  S2 extends T,
+  ItemType extends string
+>(
+  self: Repository<T, PM, Evt, Id, ItemType>,
+  item: S1,
+  pure: Effect<FixEnv<R, Evt, S1, S2>, E, A>
+) {
+  return saveAllWithEffectInt(
+    self,
+    pure.runTerm(item)
+    .map(([item, events, a]) => [[item], events, a])
+  )
+}
+
+function saveAllWithEffectInt<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  P extends T,
+  Evt,
+  ItemType extends string,
+  R,
+  E,
+  A
+>(
+  self: Repository<T, PM, Evt, Id, ItemType>,
+  gen: Effect<R, E, readonly [Iterable<P>, Iterable<Evt>, A]>
+) {
+  return gen
+    .flatMap(
+      ([items, events, a]) =>
+        self.save(items, events)
+          .map(() => a)
+    )
+}
+
+const anyDSL = makeDSL<any, any, any>()
+
+export type AllDSL<T, Evt> =
+  (<R, A, E, S1 extends T, S2 extends T>(pure: (dsl: PureDSL<Chunk<S1>, Iterable<S2>, Evt>) => Effect<R, E, A>) => Effect<FixEnv<R, Evt, Chunk<S1>, Iterable<S2>>, E, A>)
+    & AllDSLExt<T, Evt>
+
+  
+/**
+ * @tsplus type DSLExt
+ */
+export interface AllDSLExt<T, Evt>  {
+  modify: <R, E, A, S1 extends T, S2 extends T>(pure: (items: Chunk<S1>, dsl: PureDSL<Chunk<S1>, Iterable<S2>, Evt>) => Effect<R, E, A>) => Effect<FixEnv<R, Evt, Chunk<S1>, Iterable<S2>>, E, A>;
+  update: <R, E, S1 extends T, S2 extends T>(pure: (items: Chunk<S1>, log: (...evt: Evt[]) => PureLogT<Evt>) => Effect<R, E, Iterable<S2>>) => Effect<FixEnv<R, Evt, Chunk<S1>, Iterable<S2>>, E, Iterable<S2>>;
+}
+
+export function makeAllDSL<T, Evt>() {
+  const dsl: AllDSL<T, Evt> = anyDSL
+  return dsl
+}
+
+export type OneDSL<T, Evt> =
+(<R, A, E, S1 extends T, S2 extends T>(pure: (dsl: PureDSL<S1, S2, Evt>) => Effect<FixEnv<R, Evt, S1, S2>, E, A>) => Effect<FixEnv<R, Evt, S1, S2>, E, A>)
+& OneDSLExt<T, Evt>
+
+
+/**
+ * @tsplus type DSLExt
+ */
+export interface OneDSLExt<T, Evt> {
+  modify: <R, E, A, S1 extends T, S2 extends T>(pure: (items: S1, dsl: PureDSL<S1, S2, Evt>) => Effect<FixEnv<R, Evt, S1, S2>, E, A>) => Effect<FixEnv<R, Evt, S1, S2> | PureEnvEnv<Evt, S1, S1>, E, A>;
+  update: <R, E, S1 extends T, S2 extends T>(pure: (items: S1, log: (...evt: Evt[]) => PureLogT<Evt>) => Effect<FixEnv<R, Evt, S1, S2>, E, S2>) => Effect<FixEnv<R, Evt, S1, S2>, E, S2>;
+}
+
+/**
+ * @tsplus fluent DSLExt updateWith
+ */
+export function updateWithOne<T, Evt, S1 extends T, S2 extends T>(self: OneDSL<T, Evt>, upd: (item: S1) => S2) {
+  return self.update((_: S1) => Effect(upd(_)))
+}
+
+/**
+ * @tsplus fluent DSLExt updateWith
+ */
+export function updateWith<T, Evt, S1 extends T, S2 extends T>(self: AllDSL<T, Evt>, upd: (item: Chunk<S1>) => Iterable<S2>) {
+  return self.update((_: Chunk<S1>) => Effect(upd(_)))
+}
+
+export function makeOneDSL<T, Evt>(): OneDSL<T, Evt>  {
+  return anyDSL
+}
+
+export function makeDSL<S1, S2, Evt>() {
+  const dsl: PureDSL<S1, S2, Evt> = AnyPureDSL
+
+  function modify<
+    R,
+    E,
+    A
+  >(
+    pure: (
+      items: S1,
+      dsl: PureDSL<S1, S2, Evt>
+    ) => Effect<R, E, A>
+  ): Effect<FixEnv<R, Evt, S1, S2>, E, A> {
+    return dsl.get.flatMap(items => pure(items, dsl)) as any
+  }
+
+  function update<
+    R,
+    E
+  >(
+    pure: (
+      items: S1,
+      log: (...evt: Evt[]) => PureLogT<Evt>
+    ) => Effect<R, E, S2>
+  ): Effect<FixEnv<R, Evt, S1, S2>, E, S2> {
+    return dsl.get.flatMap(items => pure(items, dsl.log).tap(dsl.set)) as any
+  }
+
+  function withDSL<
+    R,
+    A,
+    E
+  >(
+    pure: (dsl: PureDSL<S1, S2, Evt>) => Effect<R, E, A>
+  ): Effect<FixEnv<R, Evt, S1, S2>, E, A> {
+    return pure(AnyPureDSL) as any
+  }
+
+  return Object.assign(
+    withDSL, {
+      modify,
+      update,
+    }
+  )
+}
+
+export interface DSLExt<S1, S2, Evt> extends ReturnType<typeof makeDSL<S1, S2, Evt>> { }
+
+
+export function ifAny<T, R, E, A>(fn: (items: NonEmptyReadonlyArray<T>) => Effect<R, E, A>) {
+  return (items: Iterable<T>) => Effect(items.toNonEmptyArray).flatMapOpt(fn)
+}
+
+/**
+ * @tsplus fluent Iterable ifAny
+ */
+export function ifAny_<T, R, E, A>(items: Iterable<T>, fn: (items: NonEmptyReadonlyArray<T>) => Effect<R, E, A>) {
+  return Effect(items.toNonEmptyArray).flatMapOpt(fn)
+}

package/_src/services/ServiceBus.ts

@@ -0,0 +1,111 @@
+import type {
+  OperationOptionsBase,
+  ProcessErrorArgs,
+  ServiceBusMessage,
+  ServiceBusMessageBatch,
+  ServiceBusReceivedMessage,
+  ServiceBusReceiver,
+  ServiceBusSender
+} from "@azure/service-bus"
+import { ServiceBusClient } from "@azure/service-bus"
+
+function makeClient(url: string) {
+  return Effect(() => new ServiceBusClient(url)).acquireRelease(
+    client => Effect.promise(() => client.close())
+  )
+}
+
+const Client = Tag<ServiceBusClient>()
+export const LiveServiceBusClient = (url: string) => makeClient(url).toScopedLayer(Client)
+
+function makeSender(queueName: string) {
+  return Effect.gen(function*($) {
+    const serviceBusClient = yield* $(Client.access)
+
+    return yield* $(
+      Effect(() => serviceBusClient.createSender(queueName)).acquireRelease(
+        subscription => Effect.promise(() => subscription.close())
+      )
+    )
+  })
+}
+export const Sender = Tag<ServiceBusSender>()
+
+export function LiveSender(queueName: string) {
+  return makeSender(queueName).toScopedLayer(Sender)
+}
+
+function makeReceiver(queueName: string) {
+  return Effect.gen(function*($) {
+    const serviceBusClient = yield* $(Client.access)
+
+    return yield* $(
+      Effect(() => serviceBusClient.createReceiver(queueName)).acquireRelease(
+        r => Effect.promise(() => r.close())
+      )
+    )
+  })
+}
+
+export const Receiver = Tag<ServiceBusReceiver>()
+export function LiveReceiver(queueName: string) {
+  return makeReceiver(queueName).toScopedLayer(Receiver)
+}
+
+export function sendMessages(
+  messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
+  options?: OperationOptionsBase
+) {
+  return Effect.gen(function*($) {
+    const s = yield* $(Sender.access)
+    return yield* $(Effect.promise(() => s.sendMessages(messages, options)))
+  })
+}
+
+export function subscribe<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>) {
+  return Effect.gen(function*($) {
+    const r = yield* $(Receiver.access)
+
+    const env = yield* $(Effect.environment<RMsg | RErr>())
+
+    yield* $(
+      Effect(() =>
+        r.subscribe({
+          processError: err =>
+            hndlr.processError(err)
+              .provideEnvironment(env)
+              .unsafeRunPromise
+              .catch(console.error),
+          processMessage: msg =>
+            hndlr.processMessage(msg)
+              .provideEnvironment(env)
+              .unsafeRunPromise
+          // DO NOT CATCH ERRORS here as they should return to the queue!
+        })
+      ).acquireRelease(
+        subscription => Effect.promise(() => subscription.close())
+      )
+    )
+  })
+}
+
+const SubscribeTag = Tag<Effect.Success<ReturnType<typeof subscribe>>>()
+
+export function Subscription<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>) {
+  return subscribe(hndlr).toScopedLayer(SubscribeTag)
+}
+
+export interface MessageHandlers<RMsg, RErr> {
+  /**
+   * Handler that processes messages from service bus.
+   *
+   * @param message - A message received from Service Bus.
+   */
+  processMessage(message: ServiceBusReceivedMessage): Effect<RMsg, never, void>
+  /**
+   * Handler that processes errors that occur during receiving.
+   * @param args - The error and additional context to indicate where
+   * the error originated.
+   */
+  processError(args: ProcessErrorArgs): Effect<RErr, never, void>
+}

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

@@ -0,0 +1,91 @@
+import type { StoreWhereFilter, Where } from "@effect-app/infra/services/Store"
+import { expect, test } from "vitest"
+import { makeFilters } from "../../lib/filter.js"
+import { buildWhereCosmosQuery } from "./Cosmos.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 AS f
+    
+    WHERE f.id != @id AND LOWER(f.b) = LOWER(@v0)
+    OFFSET 0 LIMIT 10`
+  })
+
+  expect(buildWhereCosmosQuery(
+    somethingsWhere(_ => _("d.-1.a", _ => _.$isnt("a2"))),
+    "Somethings",
+    "importedMarkerId",
+    undefined,
+    10
+  )).toEqual({
+    "parameters": [
+      {
+        "name": "@id",
+        "value": "importedMarkerId"
+      },
+      {
+        "name": "@v0",
+        "value": "a2"
+      }
+    ],
+    "query": `
+    SELECT f
+    FROM Somethings AS f
+    JOIN d IN f.d
+    WHERE f.id != @id AND LOWER(d.a) <> LOWER(@v0)
+    OFFSET 0 LIMIT 10`
+  })
+})