@effect-app/infra 0.132.2 → 0.133.0-next.0

package/_src/RequestContext.ts

@@ -1,18 +1,20 @@
+import { Schema2 } from "@effect-app/prelude"
 import { RequestId, UserProfileId } from "@effect-app/prelude/ids"
+import { useClassFeaturesForSchema } from "@effect-app/schema"
 
-@useClassFeaturesForSchema
-export class RequestContextParent extends ExtendedClass<
-  RequestContextParent,
-  RequestContextParent.ConstructorInput,
-  RequestContextParent.From,
-  RequestContextParent.Fields
->()({
-  _tag: literal("RequestContext"),
-  id: RequestId,
+const fields = {
   name: NonEmptyString255,
-  userProfile: struct({ sub: UserProfileId }).optional,
+  userProfile: struct({ sub: UserProfileId }).optional(),
   locale: literal("en", "de"),
-  createdAt: date.withDefault
+  createdAt: Schema2.Date.withDefaultMake(() => new Date()) // TODO
+} as const
+
+@useClassFeaturesForSchema
+export class RequestContextParent extends TaggedClass<
+  RequestContextParent
+>()("RequestContext", {
+  id: RequestId,
+  ...fields
 }) {}
 
 /**
@@ -20,22 +22,25 @@ export class RequestContextParent extends ExtendedClass<
  * @tsplus companion RequestContext.Ops
  */
 @useClassFeaturesForSchema
-export class RequestContext extends ExtendedClass<
-  RequestContext,
-  RequestContext.ConstructorInput,
-  RequestContext.From,
-  RequestContext.Fields
->()({
-  ...RequestContextParent.omit("id"),
-  id: RequestId.withDefault,
+export class RequestContext extends Schema2.TaggedClass<
+  RequestContext
+>()("RequestContext", {
+  id: RequestId.withDefault(),
   rootId: RequestId,
-  parent: RequestContextParent.optional,
-  namespace: NonEmptyString255.optional
+  parent: RequestContextParent.optional(),
+  namespace: NonEmptyString255.optional(),
+  ...fields
+  // ...RequestContextParent.omit("id").extend({
+  //   id: RequestId.withDefault(),
+  //   rootId: RequestId,
+  //   parent: RequestContextParent.optional(),
+  //   namespace: NonEmptyString255.optional()
+  // })
 }) {
   static inherit(
     this: void,
     parent: RequestContext,
-    newSelf: RequestContextParent.ConstructorInput
+    newSelf: ConstructorParameters<typeof RequestContextParent>[0]
   ) {
     return new RequestContext({
       namespace: parent?.namespace,
@@ -65,9 +70,6 @@ export namespace RequestContextParent {
    * @tsplus companion RequestContextParent.From/Ops
    */
   export class From extends FromClass<typeof RequestContextParent>() {}
-  export interface ConstructorInput
-    extends ConstructorInputApi<typeof RequestContextParent> {}
-  export interface Fields extends FieldsClass<typeof RequestContextParent> {}
 }
 export namespace RequestContext {
   /**
@@ -75,9 +77,6 @@ export namespace RequestContext {
    * @tsplus companion RequestContext.From/Ops
    */
   export class From extends FromClass<typeof RequestContext>() {}
-  export interface ConstructorInput
-    extends ConstructorInputApi<typeof RequestContext> {}
-  export interface Fields extends FieldsClass<typeof RequestContext> {}
 }
 /* eslint-enable */
 //

package/_src/_global.ext.ts

@@ -14,10 +14,10 @@ import type {} from "@effect-app/infra/services/Operations/live"
  * @tsplus global
  */
 import type {} from "@effect-app/infra/services/QueueMaker/errors"
-/**
- * @tsplus global
- */
-import type {} from "@effect-app/infra/test.arbs"
+// /**
+//  * @tsplus global
+//  */
+// import type {} from "@effect-app/infra/test.arbs"
 /**
  * @tsplus global
  */
@@ -36,3 +36,11 @@ import type {} from "@effect-app/infra/api/setupRequest"
  * @tsplus global
  */
 import {} from "@effect-app/infra/api/reportError"
+import { S } from "@effect-app/schema/schema"
+import type { ParseOptions } from "@effect/schema/AST"
+
+/**
+ * @tsplus fluent effect/schema/Schema __call
+ */
+export const parseSync = <I, A>(self: S.Schema<I, A>, u: I, options?: ParseOptions | undefined) =>
+  S.parseSync(self)(u, options)

package/_src/_global.schema.ts

@@ -5,6 +5,6 @@
 /**
  * @tsplus global
  */
-import { allowAnonymous, Delete, Get, Patch, Post, Put } from "@effect-app/prelude/schema"
+import { Delete, Get, Patch, Post, Put } from "@effect-app/prelude/schema"
 
 import "@effect-app/prelude/_global.schema"

package/_src/api/codec.ts

@@ -1,15 +1,9 @@
-import * as S from "@effect-app/schema"
-import { Encoder, Parser } from "@effect-app/schema"
+import * as S from "@effect-app/prelude/schema"
 
 export function makeCodec<
   To extends { id: Id },
-  ConstructorInput,
   From,
-  Api,
   Id
->(self: S.Schema<unknown, To, ConstructorInput, From, Api>) {
-  const decode = S.condemnDie(Parser.for(self))
-  // TODO: strict
-  const encode = Encoder.for(self)
-  return [decode, encode] as const
+>(self: S.Schema<From, To>) {
+  return [S.parseSync(self), S.encodeSync(self)] as const
 }

package/_src/api/express/schema/jwt.ts

@@ -1,37 +1,10 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/ban-types */
-import { pipe } from "@effect-app/core/Function"
-import * as S from "@effect-app/schema"
-import { These as Th } from "@effect-app/schema"
-import { jwtDecode } from "jwt-decode"
-
-export const jwtIdentifier = S.makeAnnotation<{}>()
+import * as S from "@effect-app/prelude/schema"
 
-export const jwtFromString: S.Schema<string, unknown, unknown, string, {}> = pipe(
-  // S.identity((u): u is string => typeof u === "string"),
-  S.identity((u): u is string => {
-    throw new Error("Cannot id JWT: " + u)
-  }),
-  S.constructor((n) => Th.succeed(n)),
-  //   S.arbitrary((_) => {
-  //     throw new Error("Cannot arb JWT")
-  //   }), // TODO
-  //   S.encoder((_) => {
-  //     throw new Error("can't encode")
-  //   }),
-  S.parser((p: any) => {
-    try {
-      return Th.succeed(
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        jwtDecode(p)
-      )
-    } catch (err) {
-      return Th.fail(S.leafE(S.parseStringE(p))) // "not a JWT: " + err as anyw
-    }
-  }),
-  S.mapApi(() => ({})),
-  S.annotate(jwtIdentifier, {})
-)
+import { jwtDecode } from "jwt-decode"
 
-export const jwt = S.string[">>>"](jwtFromString)
+export const jwt = S.transform(S.string, S.unknown, (_) => jwtDecode(_), (_): string => {
+  throw new Error("not implemented")
+})

package/_src/api/express/schema/{routing.ts → routing.ts.bak}

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/ban-types */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as S from "@effect-app/schema"
+import * as S from "@effect-app/prelude/schema"
 import type { Methods } from "@effect-app/schema"
 
 import type { JSONSchema, ParameterLocation, SubSchema } from "@effect-app/infra-adapters/Openapi/atlas-plutus"
@@ -16,14 +16,14 @@ export type Request<
   HeaderA,
   ReqA extends PathA & QueryA & BodyA,
   PPath extends `/${string}`
-> = S.ReqResSchemed<unknown, ReqA> & {
+> = S.REST.ReqRes<unknown, ReqA> & {
   method: Methods.Rest
   path: PPath
-  Cookie?: S.ReqRes<Record<string, string>, CookieA>
-  Path?: S.ReqRes<Record<string, string>, PathA>
-  Body?: S.ReqRes<unknown, BodyA>
-  Query?: S.ReqRes<Record<string, string>, QueryA>
-  Headers?: S.ReqRes<Record<string, string>, HeaderA>
+  Cookie?: S.REST.ReqRes<Record<string, string>, CookieA>
+  Path?: S.REST.ReqRes<Record<string, string>, PathA>
+  Body?: S.REST.ReqRes<unknown, BodyA>
+  Query?: S.REST.ReqRes<Record<string, string>, QueryA>
+  Headers?: S.REST.ReqRes<Record<string, string>, HeaderA>
   Tag: Tag<M, M>
 }
 
@@ -39,7 +39,7 @@ export interface RouteRequestHandler<
   PPath extends `/${string}`
 > {
   Request: Request<M, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, PPath>
-  Response?: S.ReqRes<unknown, ResA> | S.ReqResSchemed<unknown, ResA>
+  Response?: S.REST.ReqRes<unknown, ResA> // | S.REST.ReqResSchemed<unknown, ResA>
   ResponseOpenApi?: any
 }
 
@@ -126,7 +126,7 @@ export function makeFromSchema<ResA>(
   e: RouteDescriptor<any, any, any, any, any, any, ResA, any>
 ) {
   const jsonSchema_ = OpenApi.for
-  const jsonSchema = <E, A>(r: S.ReqRes<E, A>) => jsonSchema_(r)
+  const jsonSchema = <E, A>(r: S.REST.ReqRes<E, A>) => jsonSchema_(r)
   const { Request: Req, Response: Res_, ResponseOpenApi } = e.handler
   const r = ResponseOpenApi ?? Res_
   const Res = r ? S.extractSchema(r) : S.Void
@@ -164,7 +164,7 @@ export function makeFromSchema<ResA>(
   )
   // const makeReqSchema = schema(Req)
 
-  const makeResSchema = jsonSchema_(Res as any)
+  const makeResSchema = jsonSchema_(Res)
 
   function makeParameters(inn: ParameterLocation) {
     return (a: Option<JSONSchema | SubSchema>) => {

package/_src/errors.ts

@@ -14,14 +14,14 @@ export class NotFoundError<T extends string = string>
 export class ValidationError extends Data.TaggedError("ValidationError")<{ errors: ReadonlyArray<unknown> }> {}
 
 /** @tsplus type NotLoggedInError */
-export class NotLoggedInError extends Data.TaggedError("NotLoggedInError")<{ message?: string }> {
+export class NotLoggedInError extends Data.TaggedError("NotLoggedInError")<{ message?: string | undefined }> {
   constructor(message?: string) {
     super({ message })
   }
 }
 
 /** @tsplus type UnauthorizedError */
-export class UnauthorizedError extends Data.TaggedError("UnauthorizedError")<{ message?: string }> {
+export class UnauthorizedError extends Data.TaggedError("UnauthorizedError")<{ message?: string | undefined }> {
   constructor(message?: string) {
     super({ message })
   }
@@ -54,7 +54,9 @@ export class CauseException<E> extends Error {
     const ff = makeFiberFailure(originalCause)
     this.name = ff.name
     this.message = ff.message
-    this.stack = ff.stack
+    if (ff.stack) {
+      this.stack = ff.stack
+    }
   }
   toJSON() {
     return {
@@ -76,10 +78,15 @@ export class CauseException<E> extends Error {
 
 /** @tsplus type OptimisticConcurrencyException */
 export class OptimisticConcurrencyException extends Data.TaggedError("OptimisticConcurrencyException")<
-  { type: string; id: string; current?: string; found?: string; message: string }
+  { type: string; id: string; current?: string | undefined; found?: string | undefined; message: string }
 > {
   constructor(
-    args: { readonly type: string; readonly id: string; readonly current?: string; readonly found?: string }
+    args: {
+      readonly type: string
+      readonly id: string
+      readonly current?: string | undefined
+      readonly found?: string | undefined
+    }
   ) {
     super({ ...args, message: `Existing ${args.type} ${args.id} record changed` })
   }

package/_src/services/Emailer/Sendgrid.ts

@@ -1,3 +1,4 @@
+import { dropUndefinedT } from "@effect-app/core/utils"
 import type { EmailData } from "@sendgrid/helpers/classes/email-address.js"
 import sgMail from "@sendgrid/mail"
 import { inspect } from "util"
@@ -11,11 +12,11 @@ const makeSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subjectPr
     return {
       sendMail(msg_: EmailMsgOptionalFrom) {
         return Effect.gen(function*($) {
-          const msg: EmailMsg = {
+          const msg: EmailMsg = dropUndefinedT({
             ...msg_,
             from: msg_.from ?? defaultFrom,
             replyTo: msg_.replyTo ?? (msg_.from ? undefined : defaultReplyTo)
-          }
+          })
           const render = renderMessage(!realMail)
 
           const renderedMsg_ = render(msg)
@@ -66,18 +67,20 @@ export function renderMessage(forceFake: boolean) {
   let i = 0
   const makeId = () => i++
   return forceFake
-    ? (msg: EmailMsg) => ({
-      ...msg,
-      to: msg.to && renderFake(msg.to, makeId),
-      cc: msg.cc && renderFake(msg.cc, makeId),
-      bcc: msg.bcc && renderFake(msg.bcc, makeId)
-    })
-    : (msg: EmailMsg) => ({
-      ...msg,
-      to: msg.to && renderFakeIfTest(msg.to, makeId),
-      cc: msg.cc && renderFakeIfTest(msg.cc, makeId),
-      bcc: msg.bcc && renderFakeIfTest(msg.bcc, makeId)
-    })
+    ? (msg: EmailMsg) =>
+      dropUndefinedT({
+        ...msg,
+        to: msg.to && renderFake(msg.to, makeId),
+        cc: msg.cc && renderFake(msg.cc, makeId),
+        bcc: msg.bcc && renderFake(msg.bcc, makeId)
+      })
+    : (msg: EmailMsg) =>
+      dropUndefinedT({
+        ...msg,
+        to: msg.to && renderFakeIfTest(msg.to, makeId),
+        cc: msg.cc && renderFakeIfTest(msg.cc, makeId),
+        bcc: msg.bcc && renderFakeIfTest(msg.bcc, makeId)
+      })
 }
 
 /**

package/_src/services/QueueMaker/memQueue.ts

@@ -1,5 +1,6 @@
 import { MemQueue } from "@effect-app/infra-adapters/memQueue"
 import { RequestContext } from "@effect-app/infra/RequestContext"
+import type { Schema2 } from "@effect-app/prelude"
 import { RequestId } from "@effect-app/prelude/ids"
 import { Tracer } from "effect"
 import { RequestContextContainer } from "../RequestContextContainer.js"
@@ -16,8 +17,8 @@ export function makeMemQueue<
 >(
   queueName: string,
   queueDrainName: string,
-  schema: Schema.Schema<unknown, Evt, any, EvtE, any>,
-  drainSchema: Schema.Schema<unknown, DrainEvt, any, any, any>
+  schema: Schema2.Schema<EvtE, Evt>,
+  drainSchema: Schema2.Schema<unknown, DrainEvt>
 ) {
   return Effect.gen(function*($) {
     const mem = yield* $(MemQueue)
@@ -27,7 +28,7 @@ export function makeMemQueue<
 
     const wireSchema = struct({ body: schema, meta: QueueMeta })
     const drainW = struct({ body: drainSchema, meta: QueueMeta })
-    const parseDrain = drainW.parseCondemnDie
+    const parseDrain = flow(drainW.parse, (_) => _.orDie)
 
     return {
       publish: (...messages) =>

package/_src/services/QueueMaker/sbqueue.ts

@@ -9,6 +9,7 @@ import {
 import type {} from "@azure/service-bus"
 import { captureException } from "@effect-app/infra/errorReporter"
 import { RequestContext } from "@effect-app/infra/RequestContext"
+import type { Schema2 } from "@effect-app/prelude"
 import { RequestId } from "@effect-app/prelude/ids"
 import { struct } from "@effect-app/schema"
 import { Tracer } from "effect"
@@ -26,15 +27,15 @@ export function makeServiceBusQueue<
 >(
   _queueName: string,
   queueDrainName: string,
-  schema: Schema.Schema<unknown, Evt, any, EvtE, any>,
-  drainSchema: Schema.Schema<unknown, DrainEvt, any, any, any>
+  schema: Schema2.Schema<EvtE, Evt>,
+  drainSchema: Schema2.Schema<unknown, DrainEvt>
 ) {
   const wireSchema = struct({
     body: schema,
     meta: QueueMeta
   })
   const drainW = struct({ body: drainSchema, meta: QueueMeta })
-  const parseDrain = drainW.parseCondemnDie
+  const parseDrain = flow(drainW.parse, (_) => _.orDie)
 
   return Effect.gen(function*($) {
     const s = yield* $(Sender)

package/_src/services/QueueMaker/service.ts

@@ -22,7 +22,7 @@ export const QueueMeta = struct({
   span: struct({
     spanId: string,
     traceId: string,
-    sampled: bool.optional
+    sampled: boolean.optional()
   })
-    .optional
+    .optional()
 })

package/_src/services/Repository.ts

@@ -3,6 +3,7 @@
 // Modify = Must `set` updated items, and can return anything.
 import type { FixEnv, PureLogT } from "@effect-app/prelude/Pure"
 import { Pure } from "@effect-app/prelude/Pure"
+import type { S } from "vitest/dist/reporters-O4LBziQ_.js"
 import type { InvalidStateError, OptimisticConcurrencyException } from "../errors.js"
 import { NotFoundError } from "../errors.js"
 import type { Filter, PersistenceModelType } from "../services/Store.js"
@@ -76,10 +77,10 @@ export function projectEffect<
     R,
     E,
     {
-      filter?: Filter<PM>
-      collect?: (t: PM) => Option<S>
-      limit?: number
-      skip?: number
+      filter?: Filter<PM> | undefined
+      collect?: ((t: PM) => Option<S>) | undefined
+      limit?: number | undefined
+      skip?: number | undefined
     }
   >
 ): Effect<R, E, S[]>
@@ -97,10 +98,10 @@ export function projectEffect<
     R,
     E,
     {
-      filter?: QueryBuilder<PM>
-      select: NonEmptyReadonlyArray<U>
-      limit?: number
-      skip?: number
+      filter?: QueryBuilder<PM> | undefined
+      collect?: ((t: PM) => Option<S>) | undefined
+      limit?: number | undefined
+      skip?: number | undefined
     }
   >
 ): Effect<R, E, Pick<PM, U>[]>
@@ -119,11 +120,11 @@ export function projectEffect<
     R,
     E,
     {
-      filter?: Filter<PM>
-      select?: NonEmptyReadonlyArray<U>
-      collect?: (t: Pick<PM, U>) => Option<S>
-      limit?: number
-      skip?: number
+      filter?: Filter<PM> | undefined
+      select?: NonEmptyReadonlyArray<U> | undefined
+      collect?: ((t: PM) => Option<S>) | undefined
+      limit?: number | undefined
+      skip?: number | undefined
     }
   >
 ): Effect<R, E, S[]> {

package/_src/services/RepositoryBase.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/ban-types */
-import type { ParserEnv } from "@effect-app/schema/custom/Parser"
+// import type { ParserEnv } from "@effect-app/schema/custom/Parser"
 import type { Repository } from "./Repository.js"
 import { StoreMaker } from "./Store.js"
 import type { Filter, FilterArgs, FilterFunc, PersistenceModelType, StoreConfig, Where } from "./Store.js"
@@ -9,8 +9,7 @@ import type {} from "effect/Hash"
 import type { Opt } from "@effect-app/core/Option"
 import { makeCodec } from "@effect-app/infra/api/codec"
 import { makeFilters } from "@effect-app/infra/filter"
-import type { Schema } from "@effect-app/prelude"
-import { EParserFor } from "@effect-app/prelude/schema"
+import type { Schema2 } from "@effect-app/prelude"
 import type { InvalidStateError, OptimisticConcurrencyException } from "../errors.js"
 import { ContextMapContainer } from "./Store/ContextMapContainer.js"
 import { QueryBuilder } from "./Store/filterApi/query.js"
@@ -32,7 +31,7 @@ export abstract class RepositoryBaseC<
     events?: Iterable<Evt>
   ) => Effect<never, InvalidStateError | OptimisticConcurrencyException, void>
   abstract readonly utils: {
-    parseMany: (a: readonly PM[], env?: ParserEnv | undefined) => Effect<never, never, readonly T[]>
+    parseMany: (a: readonly PM[]) => Effect<never, never, readonly T[]>
     all: Effect<never, never, PM[]>
     filter: FilterFunc<PM>
     // count: (filter?: Filter<PM>) => Effect<never, never, PositiveInt>
@@ -89,12 +88,10 @@ export function makeRepo<
   return <
     ItemType extends string,
     T extends { id: string },
-    ConstructorInput,
-    Api,
     From extends { id: string }
   >(
     name: ItemType,
-    schema: Schema.Schema<unknown, T, ConstructorInput, From, Api>,
+    schema: Schema2.Schema<From, T>,
     mapFrom: (pm: Omit<PM, "_etag">) => From,
     mapTo: (e: From, etag: string | undefined) => PM
   ) => {
@@ -146,7 +143,7 @@ export function makeRepo<
           })
         )
 
-        const parse = EParserFor(schema).condemnDie
+        const parse = (e: From) => schema.parse(e).orDie
 
         const all = allE.flatMap((_) => _.forEachEffect((_) => parse(_)))
 
@@ -162,7 +159,7 @@ export function makeRepo<
         }
 
         function find(id: T["id"]) {
-          return findE(id).flatMapOpt(EParserFor(schema).condemnDie)
+          return findE(id).flatMapOpt(parse)
         }
 
         const saveAllE = (a: Iterable<From>) =>
@@ -175,7 +172,7 @@ export function makeRepo<
                 ret.forEach((_) => set(_.id, _._etag))
               })
             )
-        const encode = Encoder.for(schema)
+        const encode = (i: T) => schema.encodeSync(i)
 
         const saveAll = (a: Iterable<T>) => saveAllE(a.toChunk.map(encode))
 
@@ -208,7 +205,7 @@ export function makeRepo<
           })
         }
 
-        const p = Parser.for(schema).unsafe
+        const p = schema.parseSync
 
         const r: Repository<T, PM, Evt, ItemType> = {
           /**
@@ -301,18 +298,16 @@ export function makeStore<
   return <
     ItemType extends string,
     T extends { id: string },
-    ConstructorInput,
-    Api,
     E extends { id: string }
   >(
     name: ItemType,
-    schema: Schema.Schema<unknown, T, ConstructorInput, E, Api>,
+    schema: Schema2.Schema<E, T>,
     mapTo: (e: E, etag: string | undefined) => PM
   ) => {
     const [_dec, encode] = makeCodec(schema)
     function encodeToPM() {
       const getEtag = () => undefined
-      return flow(encode, (v) => mapToPersistenceModel(v, getEtag))
+      return (t: T) => mapToPersistenceModel(encode(t), getEtag)
     }
 
     function mapToPersistenceModel(
@@ -414,9 +409,9 @@ export const RepositoryBaseImpl = <Service>() => {
     PM extends { id: string; _etag: string | undefined },
     Evt = never
   >() =>
-  <ItemType extends string, T extends { id: string }, ConstructorInput, Api, From extends { id: string }>(
+  <ItemType extends string, T extends { id: string }, From extends { id: string }>(
     itemType: ItemType,
-    schema: Schema.Schema<unknown, T, ConstructorInput, From, Api>,
+    schema: Schema2.Schema<From, T>,
     jitM?: (pm: From) => From
   ): Exact<PM, From & { _etag: string | undefined }> extends true ?
       & (abstract new() => RepositoryBaseC1<T, PM, Evt, ItemType>)
@@ -455,9 +450,9 @@ export const RepositoryDefaultImpl = <Service>() => {
     PM extends { id: string; _etag: string | undefined },
     Evt = never
   >() =>
-  <ItemType extends string, T extends { id: string }, ConstructorInput, Api, From extends { id: string }>(
+  <ItemType extends string, T extends { id: string }, From extends { id: string }>(
     itemType: ItemType,
-    schema: Schema.Schema<unknown, T, ConstructorInput, From, Api>,
+    schema: Schema2.Schema<From, T>,
     jitM?: (pm: From) => From
   ): Exact<PM, From & { _etag: string | undefined }> extends true ?
       & (abstract new(
@@ -495,21 +490,3 @@ export const RepositoryDefaultImpl = <Service>() => {
     return assignTag<Service>()(Cls) as any // impl is missing, but its marked protected
   }
 }
-
-// @useClassFeaturesForSchema
-// export class Shop extends Class<Shop>()({ id: string }) {}
-
-// /**
-//  * @tsplus type ShopRepo
-//  * @tsplus companion ShopRepo.Ops
-//  */
-// export class ShopRepo extends RepositoryDefaultImpl<ShopRepo>()<Shop & { _etag: string | undefined }>()(
-//   "Shop",
-//   Shop,
-//   (pm) => pm,
-//   (e, _etag) => ({ ...e, _etag })
-// ) {
-//   override saveAndPublish = (items: Iterable<Shop>, events?: Iterable<unknown> | undefined) => {
-//     return this.impl.saveAndPublish(items, events)
-//   }
-// }