@effect-app/infra 0.223.2 → 0.225.0

package/dist/services/Store/service.js

@@ -1,10 +1,9 @@
-import { Effect } from "effect-app";
-import { TagClassId, TagClassMakeId } from "effect-app/service";
+import { Context, Effect } from "effect-app";
 /**
  * @tsplus type StoreMaker
  * @tsplus companion StoreMaker.Ops
  */
-export class StoreMaker extends TagClassId("effect-app/StoreMaker")() {
+export class StoreMaker extends Context.TagId("effect-app/StoreMaker")() {
 }
 export const makeContextMap = () => {
     const etags = new Map();
@@ -70,6 +69,6 @@ const makeMap = Effect.sync(() => makeContextMap());
  * @tsplus type ContextMap
  * @tsplus companion ContextMap.Ops
  */
-export class ContextMap extends TagClassMakeId("effect-app/ContextMap", makeMap)() {
+export class ContextMap extends Context.TagMakeId("effect-app/ContextMap", makeMap)() {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zZXJ2aWNlcy9TdG9yZS9zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxZQUFZLENBQUE7QUFFbkMsT0FBTyxFQUFFLFVBQVUsRUFBRSxjQUFjLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQTtBQXdFL0Q7OztHQUdHO0FBQ0gsTUFBTSxPQUFPLFVBQVcsU0FBUSxVQUFVLENBQUMsdUJBQXVCLENBQUMsRUFNL0Q7Q0FDSDtBQUVELE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxHQUFHLEVBQUU7SUFDakMsTUFBTSxLQUFLLEdBQUcsSUFBSSxHQUFHLEVBQWtCLENBQUE7SUFDdkMsTUFBTSxPQUFPLEdBQUcsQ0FBQyxFQUFVLEVBQUUsRUFBRSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUE7SUFDN0MsTUFBTSxPQUFPLEdBQUcsQ0FBQyxFQUFVLEVBQUUsSUFBd0IsRUFBRSxFQUFFO1FBQ3ZELElBQUksS0FBSyxTQUFTLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsRUFBRSxFQUFFLElBQUksQ0FBQyxDQUFBO0lBQzdELENBQUMsQ0FBQTtJQUVELCtCQUErQjtJQUMvQiwyQkFBMkI7SUFDM0IsZ0RBQWdEO0lBQ2hELE1BQU07SUFFTiwrQkFBK0I7SUFDL0IsMkJBQTJCO0lBQzNCLHNDQUFzQztJQUN0QyxNQUFNO0lBRU4sa0NBQWtDO0lBQ2xDLHdCQUF3QjtJQUN4QixvQ0FBb0M7SUFDcEMsU0FBUztJQUNULDJCQUEyQjtJQUMzQixjQUFjO0lBQ2QsSUFBSTtJQUVKLGlDQUFpQztJQUNqQyxvRkFBb0Y7SUFDcEYsb0lBQW9JO0lBQ3BJLGdCQUFnQjtJQUNoQixhQUFhO0lBQ2IsNEdBQTRHO0lBQzVHLHNDQUFzQztJQUN0QyxrRUFBa0U7SUFDbEUsdURBQXVEO0lBQ3ZELHNCQUFzQjtJQUN0QixzQkFBc0I7SUFDdEIsU0FBUztJQUNULHFDQUFxQztJQUNyQyx5Q0FBeUM7SUFDekMsaUJBQWlCO0lBQ2pCLDZCQUE2QjtJQUM3QixtQkFBbUI7SUFDbkIsK0NBQStDO0lBQy9DLHFCQUFxQjtJQUNyQixtQkFBbUI7SUFDbkIsMkNBQTJDO0lBQzNDLHlCQUF5QjtJQUN6QixzQkFBc0I7SUFDdEIsWUFBWTtJQUNaLGlCQUFpQjtJQUNqQix5Q0FBeUM7SUFDekMscURBQXFEO0lBQ3JELG9CQUFvQjtJQUNwQixVQUFVO0lBQ1YsUUFBUTtJQUNSLE1BQU07SUFDTixJQUFJO0lBRUosT0FBTztRQUNMLEdBQUcsRUFBRSxPQUFPO1FBQ1osR0FBRyxFQUFFLE9BQU87UUFDWixZQUFZO0tBQ2IsQ0FBQTtBQUNILENBQUMsQ0FBQTtBQUVELE1BQU0sT0FBTyxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsY0FBYyxFQUFFLENBQUMsQ0FBQTtBQUVuRDs7O0dBR0c7QUFDSCxNQUFNLE9BQU8sVUFBVyxTQUFRLGNBQWMsQ0FBQyx1QkFBdUIsRUFBRSxPQUFPLENBQUMsRUFBYztDQUM3RiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zZXJ2aWNlcy9TdG9yZS9zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sWUFBWSxDQUFBO0FBeUU1Qzs7O0dBR0c7QUFDSCxNQUFNLE9BQU8sVUFBVyxTQUFRLE9BQU8sQ0FBQyxLQUFLLENBQUMsdUJBQXVCLENBQUMsRUFNbEU7Q0FDSDtBQUVELE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxHQUFHLEVBQUU7SUFDakMsTUFBTSxLQUFLLEdBQUcsSUFBSSxHQUFHLEVBQWtCLENBQUE7SUFDdkMsTUFBTSxPQUFPLEdBQUcsQ0FBQyxFQUFVLEVBQUUsRUFBRSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUE7SUFDN0MsTUFBTSxPQUFPLEdBQUcsQ0FBQyxFQUFVLEVBQUUsSUFBd0IsRUFBRSxFQUFFO1FBQ3ZELElBQUksS0FBSyxTQUFTLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsRUFBRSxFQUFFLElBQUksQ0FBQyxDQUFBO0lBQzdELENBQUMsQ0FBQTtJQUVELCtCQUErQjtJQUMvQiwyQkFBMkI7SUFDM0IsZ0RBQWdEO0lBQ2hELE1BQU07SUFFTiwrQkFBK0I7SUFDL0IsMkJBQTJCO0lBQzNCLHNDQUFzQztJQUN0QyxNQUFNO0lBRU4sa0NBQWtDO0lBQ2xDLHdCQUF3QjtJQUN4QixvQ0FBb0M7SUFDcEMsU0FBUztJQUNULDJCQUEyQjtJQUMzQixjQUFjO0lBQ2QsSUFBSTtJQUVKLGlDQUFpQztJQUNqQyxvRkFBb0Y7SUFDcEYsb0lBQW9JO0lBQ3BJLGdCQUFnQjtJQUNoQixhQUFhO0lBQ2IsNEdBQTRHO0lBQzVHLHNDQUFzQztJQUN0QyxrRUFBa0U7SUFDbEUsdURBQXVEO0lBQ3ZELHNCQUFzQjtJQUN0QixzQkFBc0I7SUFDdEIsU0FBUztJQUNULHFDQUFxQztJQUNyQyx5Q0FBeUM7SUFDekMsaUJBQWlCO0lBQ2pCLDZCQUE2QjtJQUM3QixtQkFBbUI7SUFDbkIsK0NBQStDO0lBQy9DLHFCQUFxQjtJQUNyQixtQkFBbUI7SUFDbkIsMkNBQTJDO0lBQzNDLHlCQUF5QjtJQUN6QixzQkFBc0I7SUFDdEIsWUFBWTtJQUNaLGlCQUFpQjtJQUNqQix5Q0FBeUM7SUFDekMscURBQXFEO0lBQ3JELG9CQUFvQjtJQUNwQixVQUFVO0lBQ1YsUUFBUTtJQUNSLE1BQU07SUFDTixJQUFJO0lBRUosT0FBTztRQUNMLEdBQUcsRUFBRSxPQUFPO1FBQ1osR0FBRyxFQUFFLE9BQU87UUFDWixZQUFZO0tBQ2IsQ0FBQTtBQUNILENBQUMsQ0FBQTtBQUVELE1BQU0sT0FBTyxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsY0FBYyxFQUFFLENBQUMsQ0FBQTtBQUVuRDs7O0dBR0c7QUFDSCxNQUFNLE9BQU8sVUFBVyxTQUFRLE9BQU8sQ0FBQyxTQUFTLENBQUMsdUJBQXVCLEVBQUUsT0FBTyxDQUFDLEVBQWM7Q0FDaEcifQ==

package/dist/services/query/new-kid-interpreter.d.ts

@@ -14,7 +14,7 @@ export declare const toFilter: <TFieldValues extends FieldValues, A, R>(q: QAll<
         key: import("../../filter/types/path/eager.js").Path<TFieldValues>;
         direction: "ASC" | "DESC";
     }[]];
-    ttype: "one" | "many" | "count";
+    ttype: "many" | "one" | "count";
     mode: "project" | "collect" | "transform";
     filter: QueryBuilder<any>;
 };

package/examples/query.ts

@@ -0,0 +1,60 @@
+import { RepositoryDefaultImpl } from "@effect-app/infra/services/RepositoryBase"
+import { Effect, flow, Layer, ManagedRuntime, S } from "effect-app"
+import { and, or, order, page, project, where } from "../src/services/query.js"
+import { ContextMapContainer } from "../src/services/Store/ContextMapContainer.js"
+import { MemoryStoreLive } from "../src/services/Store/Memory.js"
+
+const str = S.struct({ _tag: S.literal("string"), value: S.string })
+const num = S.struct({ _tag: S.literal("number"), value: S.number })
+const someUnion = S.union(str, num)
+
+export class Something extends S.Class<Something>()({
+  id: S.StringId.withDefault,
+  displayName: S.NonEmptyString255,
+  n: S.Date.withDefault,
+  union: someUnion.pipe(S.withDefaultConstructor(() => ({ _tag: "string" as const, value: "hi" })))
+}) {}
+export declare namespace Something {
+  export interface Encoded extends S.Schema.Encoded<typeof Something> {}
+}
+
+const items = [
+  new Something({ displayName: S.NonEmptyString255("Verona"), n: new Date("2020-01-01T00:00:00Z") }),
+  new Something({ displayName: S.NonEmptyString255("Riley") }),
+  new Something({
+    displayName: S.NonEmptyString255("Riley"),
+    n: new Date("2020-01-01T00:00:00Z"),
+    union: { _tag: "number", value: 1 }
+  })
+]
+
+class SomethingRepo extends RepositoryDefaultImpl<SomethingRepo>()(
+  "Something",
+  Something
+) {
+  static readonly Test = Layer
+    .effect(
+      SomethingRepo,
+      SomethingRepo.makeWith({ makeInitial: Effect.sync(() => items) }, (_) => new SomethingRepo(_))
+    )
+    .pipe(
+      Layer.provide(Layer.merge(MemoryStoreLive, ContextMapContainer.live))
+    )
+}
+
+const program = Effect.gen(function*($) {
+  const r = yield* $(SomethingRepo.query(flow(
+    where("displayName", "Verona"),
+    or(
+      where("displayName", "Riley"),
+      and("n", "gt", "2021-01-01T00:00:00Z") // TODO: work with To type translation, so Date?
+    ),
+    order("displayName"),
+    page({ take: 1 }),
+    project(S.struct(Something.pick("id", "displayName")))
+  )))
+  console.log("$$ result", r)
+})
+
+const rt = ManagedRuntime.make(SomethingRepo.Test)
+rt.runFork(program)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/infra",
-  "version": "0.223.2",
+  "version": "0.225.0",
   "license": "MIT",
   "type": "module",
   "dependencies": {
@@ -18,11 +18,11 @@
     "proper-lockfile": "^4.1.2",
     "pure-rand": "6.0.4",
     "redlock": "^4.2.0",
-    "@effect-app/core": "0.157.0",
-    "@effect-app/infra-adapters": "0.145.0",
-    "@effect-app/schema": "0.210.2",
-    "@effect-app/fluent-extensions": "0.152.0",
-    "effect-app": "0.190.0"
+    "@effect-app/core": "0.159.0",
+    "@effect-app/fluent-extensions": "0.153.0",
+    "@effect-app/infra-adapters": "0.146.0",
+    "effect-app": "0.192.0",
+    "@effect-app/schema": "0.211.1"
   },
   "devDependencies": {
     "@babel/cli": "^7.23.9",

package/src/_ext/Array.ts

@@ -1,6 +1,4 @@
 import { Chunk, Effect, Equal } from "effect-app"
-import type { ObjectOps } from "effect-app/utils"
-import { inspect } from "util"
 import { NotFoundError } from "../errors.js"
 
 /**
@@ -22,15 +20,3 @@ export function getFirstById<A extends { id: unknown }, Type extends string>(
       Effect.mapError(() => new NotFoundError<Type>({ type, id }))
     )
 }
-
-/**
- * @tsplus fluent Object.Ops inspect
- */
-export function RecordInspect<TT extends object>(
-  o: ObjectOps<TT>,
-  showHidden?: boolean | undefined,
-  depth?: number | null | undefined,
-  color?: boolean | undefined
-) {
-  return inspect(o.subject, showHidden, depth, color)
-}

package/src/api/routing/schema/jwt.ts

@@ -1,8 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/ban-types */
-import type { ParseIssue } from "@effect/schema/ParseResult"
-import type { Effect } from "effect-app"
 import * as S from "effect-app/schema"
 import { jwtDecode, type JwtDecodeOptions } from "jwt-decode"
 
@@ -11,16 +9,13 @@ export const parseJwt = <R, I, A>(
   options?: JwtDecodeOptions | undefined
 ): S.Schema<A, string, R> =>
   S
-    .transformOrFail(
+    .transformToOrFail(
       S.string,
       S.unknown,
       (s, __, ast) =>
         S.ParseResult.try({
           try: () => jwtDecode(s, options),
           catch: (e: any) => new S.ParseResult.Type(ast, s, e?.message)
-        }),
-      (_): Effect<string, ParseIssue> => {
-        throw new Error("not implemented")
-      }
+        })
     )
     .pipe(S.compose(schema, { strict: false }))

package/src/services/Emailer/service.ts

@@ -2,14 +2,13 @@ import type { Email, NonEmptyString255 } from "@effect-app/schema"
 import type { MailContent, MailData } from "@sendgrid/helpers/classes/mail.js"
 import type { ResponseError } from "@sendgrid/mail"
 import type sgMail from "@sendgrid/mail"
-import type { Effect, NonEmptyReadonlyArray, Secret } from "effect-app"
-import { TagClassId } from "effect-app/service"
+import { Context, type Effect, type NonEmptyReadonlyArray, type Secret } from "effect-app"
 
 /**
  * @tsplus type Emailer
  * @tsplus companion Emailer.Ops
  */
-export class Emailer extends TagClassId("effect-app/Emailer")<Emailer, {
+export class Emailer extends Context.TagId("effect-app/Emailer")<Emailer, {
   sendMail: (msg: EmailMsgOptionalFrom) => Effect<void, Error | ResponseError>
 }>() {}
 

package/src/services/Operations.ts

@@ -1,7 +1,6 @@
 import type { StringId } from "@effect-app/schema"
-import { Cause, copy, Duration, Effect, Exit, Layer, Option, S, Schedule } from "effect-app"
+import { Cause, Context, copy, Duration, Effect, Exit, Layer, Option, S, Schedule } from "effect-app"
 import type { OperationProgress } from "effect-app/Operations"
-import { TagClassMakeId } from "effect-app/service"
 import * as Scope from "effect/Scope"
 import { forkDaemonReportRequestUnexpected } from "../api/reportError.js"
 
@@ -97,7 +96,7 @@ const make = Effect.sync(() => {
   }
 })
 
-export class Operations extends TagClassMakeId("effect-app/Operations", make)<Operations>() {
+export class Operations extends Context.TagMakeId("effect-app/Operations", make)<Operations>() {
   private static readonly CleanupLive = this
     .use((_) =>
       _.cleanup.pipe(

package/src/services/RepositoryBase.ts

@@ -22,11 +22,10 @@ import { toNonEmptyArray } from "@effect-app/core/Array"
 import { flatMapOption } from "@effect-app/core/Effect"
 import type { ParseResult, Schema } from "@effect-app/schema"
 import { NonNegativeInt } from "@effect-app/schema"
-import type { Context, NonEmptyArray, NonEmptyReadonlyArray } from "effect-app"
-import { Chunk, Effect, flow, Option, pipe, PubSub, ReadonlyArray, S, Unify } from "effect-app"
+import type { NonEmptyArray, NonEmptyReadonlyArray } from "effect-app"
+import { Chunk, Context, Effect, flow, Option, pipe, PubSub, ReadonlyArray, S, Unify } from "effect-app"
 import { runTerm } from "effect-app/Pure"
 import type { FixEnv, PureEnv } from "effect-app/Pure"
-import { assignTag } from "effect-app/service"
 import type { NoInfer } from "effect/Types"
 import { type InvalidStateError, NotFoundError, type OptimisticConcurrencyException } from "../errors.js"
 import type { FieldValues } from "../filter/types.js"
@@ -946,7 +945,7 @@ export const RepositoryBaseImpl = <Service>() => {
     Error.stackTraceLimit = 2
     const creationError = new Error()
     Error.stackTraceLimit = limit
-    return assignTag<Service>(undefined, creationError)(Object.assign(Cls, makeRepoFunctions(Cls))) as any
+    return Context.assignTag<Service>(undefined, creationError)(Object.assign(Cls, makeRepoFunctions(Cls))) as any
   }
 }
 
@@ -992,6 +991,6 @@ export const RepositoryDefaultImpl = <Service, Evt = never>() => {
     Error.stackTraceLimit = 2
     const creationError = new Error()
     Error.stackTraceLimit = limit
-    return assignTag<Service>(undefined, creationError)(Object.assign(Cls, makeRepoFunctions(Cls))) as any // impl is missing, but its marked protected
+    return Context.assignTag<Service>(undefined, creationError)(Object.assign(Cls, makeRepoFunctions(Cls))) as any // impl is missing, but its marked protected
   }
 }

package/src/services/RequestContextContainer.ts

@@ -1,7 +1,6 @@
 import { NonEmptyString255 } from "@effect-app/schema"
 import { Context, Effect, FiberRef, Layer, Option } from "effect-app"
 import { RequestId } from "effect-app/ids"
-import { TagClassId } from "effect-app/service"
 import { RequestContext } from "../RequestContext.js"
 import { restoreFromRequestContext } from "./Store/Memory.js"
 
@@ -10,7 +9,7 @@ import { restoreFromRequestContext } from "./Store/Memory.js"
  * @tsplus companion RequestContextContainer.Ops
  */
 export abstract class RequestContextContainer
-  extends TagClassId("effect-app/RequestContextContainer")<RequestContextContainer, {
+  extends Context.TagId("effect-app/RequestContextContainer")<RequestContextContainer, {
     requestContext: Effect<RequestContext>
     update: (f: (rc: RequestContext) => RequestContext) => Effect<RequestContext>
     start: (f: RequestContext) => Effect<void>

package/src/services/Store/ContextMapContainer.ts

@@ -1,5 +1,4 @@
 import { Context, Effect, FiberRef, Layer, Option } from "effect-app"
-import { TagClassId } from "effect-app/service"
 import { ContextMap } from "./service.js"
 
 // TODO: we have to create a new contextmap on every request.
@@ -11,7 +10,7 @@ import { ContextMap } from "./service.js"
 /**
  * @tsplus companion ContextMapContainer.Ops
  */
-export abstract class ContextMapContainer extends TagClassId("effect-app/ContextMapContainer")<ContextMapContainer, {
+export abstract class ContextMapContainer extends Context.TagId("effect-app/ContextMapContainer")<ContextMapContainer, {
   get: Effect<ContextMap>
   start: Effect<void>
 }>() {

package/src/services/Store/Cosmos.ts

@@ -2,9 +2,9 @@
 
 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 { Chunk, Duration, Effect, Layer, Option, pipe, ReadonlyArray, Secret, Struct } from "effect-app"
 import type { NonEmptyReadonlyArray } from "effect-app"
-import { dropUndefinedT, omit, pick } from "effect-app/utils"
+import { dropUndefinedT } from "effect-app/utils"
 import { OptimisticConcurrencyException } from "../../errors.js"
 import { buildWhereCosmosQuery3, logQuery } from "./Cosmos/query.js"
 import { StoreMaker } from "./service.js"
@@ -18,7 +18,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
   return Effect.gen(function*($) {
     const { db } = yield* $(CosmosClient)
     return {
-      make: <Id extends string, Encoded extends { id: Id }, R = never, E = never>(
+      make: <Id extends string, Encoded extends Record<string, any> & { id: Id }, R = never, E = never>(
         name: string,
         seed?: Effect<Iterable<Encoded>, E, R>,
         config?: StoreConfig<Encoded>
@@ -56,7 +56,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                           dropUndefinedT({
                             operationType: "Create" as const,
                             resourceBody: {
-                              ...omit(x, "_etag"),
+                              ...Struct.omit(x, "_etag"),
                               _partitionKey: config?.partitionValue(x)
                             },
                             partitionKey: config?.partitionValue(x)
@@ -66,7 +66,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                             operationType: "Replace" as const,
                             id: x.id,
                             resourceBody: {
-                              ...omit(x, "_etag"),
+                              ...Struct.omit(x, "_etag"),
                               _partitionKey: config?.partitionValue(x)
                             },
                             ifMatch: eTag,
@@ -139,7 +139,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                         onNone: () => ({
                           operationType: "Create" as const,
                           resourceBody: {
-                            ...omit(x, "_etag"),
+                            ...Struct.omit(x, "_etag"),
                             _partitionKey: config?.partitionValue(x)
                           }
                         }),
@@ -147,7 +147,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                           operationType: "Replace" as const,
                           id: x.id,
                           resourceBody: {
-                            ...omit(x, "_etag"),
+                            ...Struct.omit(x, "_etag"),
                             _partitionKey: config?.partitionValue(x)
                           },
                           ifMatch: eTag
@@ -250,7 +250,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                             .query<M>(q)
                             .fetchAll()
                             .then(({ resources }) =>
-                              resources.map((_) => ({ ...pick(defaultValues, f.select!), ..._ }))
+                              resources.map((_) => ({ ...pipe(defaultValues, Struct.pick(...f.select!)), ..._ }))
                             )
                           : container
                             .items

package/src/services/Store/Memory.ts

@@ -1,8 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { Effect, FiberRef, flow, Option, Order, pipe, ReadonlyArray, Ref } from "effect-app"
+import { Effect, FiberRef, flow, Option, Order, pipe, ReadonlyArray, Ref, Struct } from "effect-app"
 import type { NonEmptyArray, NonEmptyReadonlyArray } from "effect-app"
-import { get, pick } from "effect-app/utils"
+import { get } from "effect-app/utils"
 import type { RequestContext } from "../../RequestContext.js"
 import type { FilterArgs, PersistenceModelType, Store, StoreConfig } from "./service.js"
 import { StoreMaker } from "./service.js"
@@ -11,7 +11,7 @@ import { codeFilter, makeUpdateETag } from "./utils.js"
 export function memFilter<T extends { id: string }, U extends keyof T = never>(f: FilterArgs<T, U>) {
   type M = U extends undefined ? T : Pick<T, U>
   return ((c: T[]): M[] => {
-    const select = (r: T[]): M[] => (f.select ? r.map((_) => pick(_, f.select!)) : r) as any
+    const select = (r: T[]): M[] => (f.select ? r.map(Struct.pick(...f.select)) : r) as any
     const skip = f?.skip
     const limit = f?.limit
     const ords = Option.map(Option.fromNullable(f.order), (_) =>

package/src/services/Store/service.ts

@@ -1,8 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { UniqueKey } from "@azure/cosmos"
-import { Effect } from "effect-app"
+import { Context, Effect } from "effect-app"
 import type { NonEmptyReadonlyArray, Option, Secret } from "effect-app"
-import { TagClassId, TagClassMakeId } from "effect-app/service"
 import type { OptimisticConcurrencyException } from "../../errors.js"
 import type { FieldValues } from "../../filter/types.js"
 import type { QueryBuilder } from "./filterApi/query.js"
@@ -78,7 +77,7 @@ export interface Store<
  * @tsplus type StoreMaker
  * @tsplus companion StoreMaker.Ops
  */
-export class StoreMaker extends TagClassId("effect-app/StoreMaker")<StoreMaker, {
+export class StoreMaker extends Context.TagId("effect-app/StoreMaker")<StoreMaker, {
   make: <Encoded extends { id: Id }, Id extends string, R = never, E = never>(
     name: string,
     seed?: Effect<Iterable<Encoded>, E, R>,
@@ -158,10 +157,10 @@ const makeMap = Effect.sync(() => makeContextMap())
  * @tsplus type ContextMap
  * @tsplus companion ContextMap.Ops
  */
-export class ContextMap extends TagClassMakeId("effect-app/ContextMap", makeMap)<ContextMap>() {
+export class ContextMap extends Context.TagMakeId("effect-app/ContextMap", makeMap)<ContextMap>() {
 }
 
-export type PersistenceModelType<Encoded> = Encoded & {
+export type PersistenceModelType<Encoded extends Object> = Encoded & {
   _etag?: string | undefined
 }
 

package/test/dist/query.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAQ,KAAK,EAAgB,CAAC,EAAE,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcjE,qBAAa,SAAU,SAAQ,cAK7B;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC;IACjC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,SAAS,CAAC;KAAG;CACvE;;;;;;;;;;;;;;;;;;;;;;;;;AAGD,qBAAa,WAAY,SAAQ,gBAA6D;CAAG"}
+{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAQ,KAAK,EAAgB,CAAC,EAAU,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYlF,qBAAa,SAAU,SAAQ,cAK7B;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC;IACjC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,SAAS,CAAC;KAAG;CACvE;;;;;;;;;;;;;;;;;;;;;;;;;AAGD,qBAAa,WAAY,SAAQ,gBAAgE;CAAG"}

package/test/query.test.ts

@@ -1,6 +1,4 @@
-import { Effect, flow, Layer, Option, pipe, S } from "effect-app"
-import { TagClassMakeId } from "effect-app/service"
-import { pick } from "effect-app/utils"
+import { Context, Effect, flow, Layer, Option, pipe, S, Struct } from "effect-app"
 import { inspect } from "util"
 import { expect, it } from "vitest"
 import { and, make, one, or, order, page, project, toFilter, where } from "../src/services/query.js"
@@ -23,7 +21,7 @@ export declare namespace Something {
 }
 
 const MakeSomeService = Effect.succeed({ a: 1 })
-export class SomeService extends TagClassMakeId("SomeService", MakeSomeService)<SomeService>() {}
+export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)<SomeService>() {}
 
 const q = make<Something.Encoded>()
   .pipe( // provided automatically inside Repo.q2()
@@ -37,7 +35,7 @@ const q = make<Something.Encoded>()
     project(
       S.transformToOrFail(
         S.struct({ id: S.StringId, displayName: S.string }), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
-        S.struct(pick(Something.fields, "id", "displayName")),
+        S.struct(Struct.pick(Something.fields, "id", "displayName")),
         (_) => Effect.andThen(SomeService, _)
       )
     )
@@ -87,7 +85,7 @@ it("works", () => {
 
   const processed = memFilter(interpreted)(items.map((_) => S.encodeSync(Something)(_)))
 
-  expect(processed).toEqual(items.slice(0, 2).toReversed().map((_) => pick(_, "id", "displayName")))
+  expect(processed).toEqual(items.slice(0, 2).toReversed().map(Struct.pick("id", "displayName")))
 })
 
 class SomethingRepo extends RepositoryDefaultImpl<SomethingRepo>()(
@@ -117,17 +115,16 @@ it("works with repo", () =>
             order("displayName"),
             page({ take: 10 }),
             project(
-              S.transformOrFail(
+              S.transformToOrFail(
                 S.struct({ displayName: S.string }), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
-                S.struct(pick(Something.fields, "displayName")),
-                (_) => Effect.andThen(SomeService, _),
-                () => Effect.die(new Error("not implemented"))
+                S.struct(Struct.pick(Something.fields, "displayName")),
+                (_) => Effect.andThen(SomeService, _)
               )
             )
           ))
       )
-      expect(q1).toEqual(items.slice(0, 2).toReversed().map((_) => pick(_, "id", "displayName")))
-      expect(q2).toEqual(items.slice(0, 2).toReversed().map((_) => pick(_, "displayName")))
+      expect(q1).toEqual(items.slice(0, 2).toReversed().map(Struct.pick("id", "displayName")))
+      expect(q2).toEqual(items.slice(0, 2).toReversed().map(Struct.pick("displayName")))
     })
     .pipe(Effect.provide(Layer.mergeAll(SomethingRepo.Test, SomeService.toLayer())), Effect.runPromise))
 
@@ -145,7 +142,7 @@ it("collect", () =>
               project(
                 S.transformTo(
                   // TODO: sample case with narrowing down a union?
-                  S.encodedSchema(S.struct(pick(Something.fields, "displayName", "n"))), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
+                  S.encodedSchema(S.struct(Struct.pick(Something.fields, "displayName", "n"))), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
                   S.typeSchema(S.option(S.string)),
                   (_) =>
                     _.displayName === "Riley" && _.n === "2020-01-01T00:00:00.000Z"
@@ -168,7 +165,7 @@ it("collect", () =>
               project(
                 S.transformTo(
                   // TODO: sample case with narrowing down a union?
-                  S.encodedSchema(S.struct(pick(Something.fields, "union"))), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
+                  S.encodedSchema(S.struct(Struct.pick(Something.fields, "union"))), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
                   S.typeSchema(S.option(S.string)),
                   (_) =>
                     _.union._tag === "string"

package/tsconfig.examples.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": [
+    "examples"
+  ],
+  "references": [
+    {
+      "path": "tsconfig.src.json"
+    }
+  ],
+  "compilerOptions": {
+    "tsBuildInfoFile": ".tsbuildinfo/examples.tsbuildinfo",
+    "rootDir": "examples",
+    "noEmit": true
+  }
+}

package/tsconfig.json.bak

@@ -7,6 +7,9 @@
     },
     {
       "path": "./tsconfig.test.json"
+    },
+    {
+      "path": "./tsconfig.examples.json"
     }
   ],
 }