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

package/_src/services/Store/Cosmos.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { CosmosClient, CosmosClientLayer } from "@effect-app/infra-adapters/cosmos-client"
-import { omit, pick } from "@effect-app/prelude/utils"
+import { dropUndefinedT, omit, pick } from "@effect-app/prelude/utils"
 import { OptimisticConcurrencyException } from "../../errors.js"
 import {
   buildCosmosQuery,
@@ -37,12 +37,12 @@ function makeCosmosStore({ prefix }: StorageConfig) {
           const containerId = `${prefix}${name}`
           yield* $(
             Effect.promise(() =>
-              db.containers.createIfNotExists({
+              db.containers.createIfNotExists(dropUndefinedT({
                 id: containerId,
                 uniqueKeyPolicy: config?.uniqueKeys
                   ? { uniqueKeys: config.uniqueKeys }
                   : undefined
-              })
+              }))
             )
           )
           const defaultValues = config?.defaultValues ?? {}
@@ -61,24 +61,26 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                     [
                       x,
                       Option.fromNullable(x._etag).match({
-                        onNone: () => ({
-                          operationType: "Create" as const,
-                          resourceBody: {
-                            ...omit(x, "_etag"),
-                            _partitionKey: config?.partitionValue(x)
-                          } as any,
-                          partitionKey: config?.partitionValue(x)
-                        }),
-                        onSome: (eTag) => ({
-                          operationType: "Replace" as const,
-                          id: x.id,
-                          resourceBody: {
-                            ...omit(x, "_etag"),
-                            _partitionKey: config?.partitionValue(x)
-                          } as any,
-                          ifMatch: eTag,
-                          partitionKey: config?.partitionValue(x)
-                        })
+                        onNone: () =>
+                          dropUndefinedT({
+                            operationType: "Create" as const,
+                            resourceBody: {
+                              ...omit(x, "_etag"),
+                              _partitionKey: config?.partitionValue(x)
+                            },
+                            partitionKey: config?.partitionValue(x)
+                          }),
+                        onSome: (eTag) =>
+                          dropUndefinedT({
+                            operationType: "Replace" as const,
+                            id: x.id,
+                            resourceBody: {
+                              ...omit(x, "_etag"),
+                              _partitionKey: config?.partitionValue(x)
+                            },
+                            ifMatch: eTag,
+                            partitionKey: config?.partitionValue(x)
+                          })
                       })
                     ] as const
                 )

package/_src/services/Store/Disk.ts

@@ -38,10 +38,12 @@ function makeDiskStoreInt<Id extends string, PM extends PersistenceModelType<Id>
             (json) =>
               fu
                 .writeTextFile(file, json)
-                .withSpan("Disk.write.writeFile [effect-app/infra/Store]")
+                .withSpan("Disk.write.writeFile [effect-app/infra/Store]", {
+                  attributes: { "disk.file_size": json.length }
+                })
           )
           .withSpan("Disk.write [effect-app/infra/Store]", {
-            attributes: { "disk.file": file, "disk.file_size": json.length }
+            attributes: { "disk.file": file }
           })
     }
 

package/_src/services/Store/service.ts

@@ -1,8 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { UniqueKey } from "@azure/cosmos"
-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"
@@ -36,8 +33,8 @@ export type Where =
 
 // default is where
 export type StoreWhereFilter = {
-  type?: "where"
-  mode?: "and" | "or" // default is and
+  type?: "where" | undefined
+  mode?: "and" | "or" | undefined // default is and
   where: readonly [
     Where,
     ...(Where[])
@@ -67,10 +64,10 @@ export type FilterJoinSelect = {
 }
 
 export interface FilterArgs<PM extends PersistenceModelType<string>, U extends keyof PM = never> {
-  filter?: Filter<PM>
-  select?: NonEmptyReadonlyArray<U>
-  limit?: number
-  skip?: number
+  filter?: Filter<PM> | undefined
+  select?: NonEmptyReadonlyArray<U> | undefined
+  limit?: number | undefined
+  skip?: number | undefined
 }
 
 export type FilterFunc<PM extends PersistenceModelType<string>> = <U extends keyof PM = never>(
@@ -118,61 +115,61 @@ export const makeContextMap = (): ContextMap => {
     eTag === undefined ? etags.delete(id) : etags.set(id, eTag)
   }
 
-  const parsedCache = new Map<
-    Parser<any, any, any>,
-    Map<unknown, These.These<unknown, unknown>>
-  >()
-
-  const parserCache = new Map<
-    Parser<any, any, any>,
-    (i: any) => These.These<any, any>
-  >()
-
-  const setAndReturn = <I, E, A>(
-    p: Parser<I, E, A>,
-    np: (i: I) => These.These<E, A>
-  ) => {
-    parserCache.set(p, np)
-    return np
-  }
-
-  const parserEnv: ParserEnv = {
-    // TODO: lax: true would turn off refinement checks, may help on large payloads
-    // but of course removes confirming of validation rules (which may be okay for a database owned by the app, as we write safely)
-    lax: false,
-    cache: {
-      getOrSetParser: (p) => parserCache.get(p) ?? setAndReturn(p, (i) => parserEnv.cache!.getOrSet(i, p)),
-      getOrSetParsers: (parsers) => {
-        return Object.entries(parsers).reduce((prev, [k, v]) => {
-          prev[k] = parserEnv.cache!.getOrSetParser(v)
-          return prev
-        }, {} as any)
-      },
-      getOrSet: (i, parse): any => {
-        const c = parsedCache.get(parse)
-        if (c) {
-          const f = c.get(i)
-          if (f) {
-            // console.log("$$$ cache hit", i)
-            return f
-          } else {
-            const nf = parse(i, parserEnv)
-            c.set(i, nf)
-            return nf
-          }
-        } else {
-          const nf = parse(i, parserEnv)
-          parsedCache.set(parse, new Map([[i, nf]]))
-          return nf
-        }
-      }
-    }
-  }
+  // const parsedCache = new Map<
+  //   Parser<any, any, any>,
+  //   Map<unknown, These.These<unknown, unknown>>
+  // >()
+
+  // const parserCache = new Map<
+  //   Parser<any, any, any>,
+  //   (i: any) => These.These<any, any>
+  // >()
+
+  // const setAndReturn = <I, E, A>(
+  //   p: Parser<I, E, A>,
+  //   np: (i: I) => These.These<E, A>
+  // ) => {
+  //   parserCache.set(p, np)
+  //   return np
+  // }
+
+  // const parserEnv: ParserEnv = {
+  //   // TODO: lax: true would turn off refinement checks, may help on large payloads
+  //   // but of course removes confirming of validation rules (which may be okay for a database owned by the app, as we write safely)
+  //   lax: false,
+  //   cache: {
+  //     getOrSetParser: (p) => parserCache.get(p) ?? setAndReturn(p, (i) => parserEnv.cache!.getOrSet(i, p)),
+  //     getOrSetParsers: (parsers) => {
+  //       return Object.entries(parsers).reduce((prev, [k, v]) => {
+  //         prev[k] = parserEnv.cache!.getOrSetParser(v)
+  //         return prev
+  //       }, {} as any)
+  //     },
+  //     getOrSet: (i, parse): any => {
+  //       const c = parsedCache.get(parse)
+  //       if (c) {
+  //         const f = c.get(i)
+  //         if (f) {
+  //           // console.log("$$$ cache hit", i)
+  //           return f
+  //         } else {
+  //           const nf = parse(i, parserEnv)
+  //           c.set(i, nf)
+  //           return nf
+  //         }
+  //       } else {
+  //         const nf = parse(i, parserEnv)
+  //         parsedCache.set(parse, new Map([[i, nf]]))
+  //         return nf
+  //       }
+  //     }
+  //   }
+  // }
 
   return {
     get: getEtag,
-    set: setEtag,
-    parserEnv
+    set: setEtag
+    // parserEnv
   }
 }
 
@@ -188,7 +185,7 @@ export const makeMap = Effect.sync(() => makeContextMap())
 export class ContextMap extends TagClass<ContextMap, {
   get: (id: string) => string | undefined
   set: (id: string, eTag: string | undefined) => void
-  parserEnv: ParserEnv
+  // parserEnv: ParserEnv
 }>() {
 }
 

package/_src/services/simpledb/memdb.ts

@@ -1,5 +1,4 @@
 import { flow } from "@effect-app/core/Function"
-import * as S from "@effect-app/schema"
 
 import type { CachedRecord, DBRecord } from "./shared.js"
 import { getRecordName, makeMap, SerializedDBRecord } from "./shared.js"
@@ -10,7 +9,7 @@ import type { Version } from "./simpledb.js"
 // Do not try this at home.
 const storage = makeMap<string, string>()
 
-const parseSDB = SerializedDBRecord.Parser >= S.condemnFail
+const parseSDB = SerializedDBRecord.parse
 
 export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>() {
   return <REncode, RDecode, EDecode>(

package/_src/services/simpledb/redisdb.ts

@@ -1,8 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { flow, pipe } from "@effect-app/core/Function"
+import { flow } from "@effect-app/core/Function"
 import { RedisClient } from "@effect-app/infra-adapters/redis-client"
-import * as S from "@effect-app/schema"
+import * as S from "@effect-app/prelude/schema"
 import type { Lock } from "redlock"
 import type { CachedRecord, DBRecord, Index } from "./shared.js"
 import { ConnectionException, CouldNotAquireDbLockException, getIndexName, getRecordName } from "./shared.js"
@@ -29,10 +29,8 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
       return RedisClient
         .flatMap((_) => _.hmgetAll(getKey(id)))
         .flatMapOpt((v) =>
-          pipe(
-            RedisSerializedDBRecord.Parser,
-            S.condemnFail
-          )(v)
+          RedisSerializedDBRecord
+            .parse(v)
             .map(({ data, version }) => ({
               data: JSON.parse(data) as EA,
               version
@@ -57,11 +55,14 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
                   .zipRight(getData(record))
                   // TODO: instead use MULTI & EXEC to make it in one command?
                   .flatMap((data) =>
-                    hmSetRec(getKey(record.id), {
-                      version,
-                      timestamp: new Date(),
-                      data
-                    })
+                    hmSetRec(
+                      getKey(record.id),
+                      new RedisSerializedDBRecord({
+                        version,
+                        timestamp: new Date(),
+                        data
+                      })
+                    )
                   )
                   .zipRight(setIndex(record))
                   .orDie
@@ -71,11 +72,14 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
           onSome: () =>
             getData(record)
               .flatMap((data) =>
-                hmSetRec(getKey(record.id), {
-                  version,
-                  timestamp: new Date(),
-                  data
-                })
+                hmSetRec(
+                  getKey(record.id),
+                  new RedisSerializedDBRecord({
+                    version,
+                    timestamp: new Date(),
+                    data
+                  })
+                )
               )
               .orDie
               .map(() => ({ version, data: record } as CachedRecord<A>))
@@ -190,6 +194,6 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
 
 export class RedisSerializedDBRecord extends S.Class<RedisSerializedDBRecord>()({
   version: S.string,
-  timestamp: S.date,
+  timestamp: S.Date,
   data: S.string
 }) {}

package/_src/services/simpledb/shared.ts

@@ -1,5 +1,4 @@
-import * as S from "@effect-app/schema"
-import type { SchemaAny } from "@effect-app/schema"
+import * as S from "@effect-app/prelude/schema"
 
 export class CouldNotAquireDbLockException
   extends Data.TaggedError("CouldNotAquireDbLockException")<{ type: string; id: string; error: Error; message: string }>
@@ -30,15 +29,15 @@ export interface DBRecord<TKey extends string> {
 
 export class SerializedDBRecord extends S.Class<SerializedDBRecord>()({
   version: S.string,
-  timestamp: S.date,
+  timestamp: S.Date,
   data: S.string
 }) {}
 
 // unknown -> string -> SDB?
-export function makeSerialisedDBRecord(s: SchemaAny) {
+export function makeSerialisedDBRecord(s: Schema<any, any>) {
   return S.struct({
     version: S.number,
-    timestamp: S.date,
+    timestamp: S.Date,
     data: s
   })
 }

package/dist/RequestContext.d.ts

@@ -1,87 +1,102 @@
-import { useClassFeaturesForSchema, ExtendedClass, literal, NonEmptyString255, struct, date, FromClass, ConstructorInputApi, FieldsClass } from "@effect-app/prelude/schema";
-import { UserProfileId } from "@effect-app/prelude/ids";
-declare const RequestContextParent_base: import("@effect-app/schema").ExtendedClass<import("@effect-app/schema").SchemaProperties<import("@effect-app/schema").ToProps<{
-    _tag: import("@effect-app/schema").DefaultSchema<unknown, "RequestContext", "RequestContext", "RequestContext", import("@effect-app/schema").LiteralApi<["RequestContext"]>>;
-    id: import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").NonEmptyString50, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").NonEmptyString255> & import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").NonEmptyString50>> & import("@effect-app/schema").Utils<import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").NonEmptyString50, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").NonEmptyString255> & import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").NonEmptyString50>>> & {
-        withDefault: import("@effect-app/schema").Field<import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").NonEmptyString50, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").NonEmptyString50>>, "required", import("effect/Option").None<any>, import("effect/Option").Some<["constructor", () => import("@effect-app/schema").NonEmptyString50]>>;
-        make: () => import("@effect-app/prelude/schema").StringId;
-    };
-    name: import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").NonEmptyString255, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").NonEmptyString255>> & import("@effect-app/schema").Utils<import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").NonEmptyString255, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").NonEmptyString255>>>;
-    userProfile: import("@effect-app/schema").Field<import("@effect-app/schema").Schema<unknown, {
-        readonly sub: UserProfileId;
-    }, {
-        readonly sub: UserProfileId;
-    }, {
+import { TaggedClass, NonEmptyString255, FromClass } from "@effect-app/prelude/schema";
+import { Schema2 } from "@effect-app/prelude";
+declare const RequestContextParent_base: Schema2.Class<{
+    readonly _tag: "RequestContext";
+    readonly id: string;
+    readonly name: string;
+    readonly locale: "en" | "de";
+    readonly createdAt: string;
+    readonly userProfile?: {
         readonly sub: string;
-    }, {
-        fields: import("@effect-app/schema").ToProps<{
-            sub: import("@effect-app/schema").SchemaDefaultSchema<unknown, UserProfileId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<UserProfileId>> & import("@effect-app/schema").Utils<import("@effect-app/schema").SchemaDefaultSchema<unknown, UserProfileId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<UserProfileId>>> & {
-                EParser: import("@effect-app/schema/custom/_parser").Parser<string, any, UserProfileId>;
-                make: () => UserProfileId;
-                eq: import("effect/Equivalence").Equivalence<UserProfileId>;
-                withDefault: import("@effect-app/schema").Field<import("@effect-app/schema").SchemaDefaultSchema<unknown, UserProfileId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<UserProfileId>>, "required", import("effect/Option").None<any>, import("effect/Option").Some<["constructor", () => UserProfileId]>>;
-            };
-        }>;
-    }>, "optional", import("effect/Option").None<any>, import("effect/Option").None<any>>;
-    locale: import("@effect-app/schema").DefaultSchema<unknown, "en" | "de", "en" | "de", "en" | "de", import("@effect-app/schema").LiteralApi<["en", "de"]>>;
-    createdAt: import("@effect-app/schema").SpecificField<import("@effect-app/schema").Schema<unknown, Date, Date, string, {}>, "required", import("effect/Option").None<any>, import("effect/Option").Some<["constructor", () => Date]>>;
-}>>, RequestContextParent, RequestContextParent.ConstructorInput, RequestContextParent.From, RequestContextParent.Fields> & import("@effect-app/schema").PropsExtensions<RequestContextParent.Fields>;
+    } | undefined;
+}, {
+    readonly _tag: "RequestContext";
+    readonly id: string & Schema2.StringIdBrand;
+    readonly name: string & Schema2.NonEmptyString255Brand;
+    readonly locale: "en" | "de";
+    readonly createdAt: Date;
+    readonly userProfile?: {
+        readonly sub: string & Schema2.StringIdBrand & import("@effect-app/prelude/ids").UserProfileIdBrand;
+    } | undefined;
+}, {
+    readonly name: string & Schema2.NonEmptyString255Brand;
+    readonly locale: "en" | "de";
+    readonly userProfile?: {
+        readonly sub: string & Schema2.StringIdBrand & import("@effect-app/prelude/ids").UserProfileIdBrand;
+    } | undefined;
+    readonly id?: string & Schema2.StringIdBrand;
+    readonly createdAt?: Date;
+}, RequestContextParent, import("effect/Data").Case>;
 export declare class RequestContextParent extends RequestContextParent_base {
 }
-declare const RequestContext_base: import("@effect-app/schema").ExtendedClass<import("@effect-app/schema").SchemaProperties<import("@effect-app/schema").ToProps<{
-    id: import("@effect-app/schema").Field<import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").NonEmptyString50, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").NonEmptyString50>>, "required", import("effect/Option").None<any>, import("effect/Option").Some<["constructor", () => import("@effect-app/schema").NonEmptyString50]>>;
-    rootId: import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").NonEmptyString50, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").NonEmptyString255> & import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").NonEmptyString50>> & import("@effect-app/schema").Utils<import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").NonEmptyString50, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").NonEmptyString255> & import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").NonEmptyString50>>> & {
-        withDefault: import("@effect-app/schema").Field<import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").NonEmptyString50, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").NonEmptyString50>>, "required", import("effect/Option").None<any>, import("effect/Option").Some<["constructor", () => import("@effect-app/schema").NonEmptyString50]>>;
-        make: () => import("@effect-app/prelude/schema").StringId;
-    };
-    parent: import("@effect-app/schema").Field<import("@effect-app/schema").Schema<unknown, RequestContextParent, RequestContextParent.ConstructorInput, RequestContextParent.From, {
-        fields: RequestContextParent.Fields;
-    }>, "optional", import("effect/Option").None<any>, import("effect/Option").None<any>>;
-    namespace: import("@effect-app/schema").Field<import("@effect-app/schema").Schema<unknown, import("@effect-app/schema").NonEmptyString255, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").NonEmptyString255>>, "optional", import("effect/Option").None<any>, import("effect/Option").None<any>>;
-    _tag: import("@effect-app/schema").Field<import("@effect-app/schema").DefaultSchema<unknown, "RequestContext", "RequestContext", "RequestContext", import("@effect-app/schema").LiteralApi<["RequestContext"]>>, "required", import("effect/Option").None<any>, import("effect/Option").None<any>>;
-    name: import("@effect-app/schema").Field<import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").NonEmptyString255, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").NonEmptyString255>> & import("@effect-app/schema").Utils<import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").NonEmptyString255, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").NonEmptyString255>>>, "required", import("effect/Option").None<any>, import("effect/Option").None<any>>;
-    userProfile: import("@effect-app/schema").Field<import("@effect-app/schema").Schema<unknown, {
-        readonly sub: UserProfileId;
-    }, {
-        readonly sub: UserProfileId;
-    }, {
+declare const RequestContext_base: Schema2.Class<{
+    readonly _tag: "RequestContext";
+    readonly id: string;
+    readonly rootId: string;
+    readonly name: string;
+    readonly locale: "en" | "de";
+    readonly createdAt: string;
+    readonly userProfile?: {
         readonly sub: string;
-    }, {
-        fields: import("@effect-app/schema").ToProps<{
-            sub: import("@effect-app/schema").SchemaDefaultSchema<unknown, UserProfileId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<UserProfileId>> & import("@effect-app/schema").Utils<import("@effect-app/schema").SchemaDefaultSchema<unknown, UserProfileId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<UserProfileId>>> & {
-                EParser: import("@effect-app/schema/custom/_parser").Parser<string, any, UserProfileId>;
-                make: () => UserProfileId;
-                eq: import("effect/Equivalence").Equivalence<UserProfileId>;
-                withDefault: import("@effect-app/schema").Field<import("@effect-app/schema").SchemaDefaultSchema<unknown, UserProfileId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<UserProfileId>>, "required", import("effect/Option").None<any>, import("effect/Option").Some<["constructor", () => UserProfileId]>>;
-            };
-        }>;
-    }>, "optional", import("effect/Option").None<any>, import("effect/Option").None<any>>;
-    locale: import("@effect-app/schema").Field<import("@effect-app/schema").DefaultSchema<unknown, "en" | "de", "en" | "de", "en" | "de", import("@effect-app/schema").LiteralApi<["en", "de"]>>, "required", import("effect/Option").None<any>, import("effect/Option").None<any>>;
-    createdAt: import("@effect-app/schema").SpecificField<import("@effect-app/schema").Schema<unknown, Date, Date, string, {}>, "required", import("effect/Option").None<any>, import("effect/Option").Some<["constructor", () => Date]>>;
-}>>, RequestContext, RequestContext.ConstructorInput, RequestContext.From, RequestContext.Fields> & import("@effect-app/schema").PropsExtensions<RequestContext.Fields>;
+    } | undefined;
+    readonly parent?: {
+        readonly _tag: "RequestContext";
+        readonly id: string;
+        readonly name: string;
+        readonly locale: "en" | "de";
+        readonly createdAt: string;
+        readonly userProfile?: {
+            readonly sub: string;
+        } | undefined;
+    } | undefined;
+    readonly namespace?: string | undefined;
+}, {
+    readonly _tag: "RequestContext";
+    readonly id: Schema2.StringId;
+    readonly rootId: string & Schema2.StringIdBrand;
+    readonly name: string & Schema2.NonEmptyString255Brand;
+    readonly locale: "en" | "de";
+    readonly createdAt: Date;
+    readonly userProfile?: {
+        readonly sub: string & Schema2.StringIdBrand & import("@effect-app/prelude/ids").UserProfileIdBrand;
+    } | undefined;
+    readonly parent?: RequestContextParent | undefined;
+    readonly namespace?: (string & Schema2.NonEmptyString255Brand) | undefined;
+}, {
+    readonly name: string & Schema2.NonEmptyString255Brand;
+    readonly locale: "en" | "de";
+    readonly userProfile?: {
+        readonly sub: string & Schema2.StringIdBrand & import("@effect-app/prelude/ids").UserProfileIdBrand;
+    } | undefined;
+    readonly parent?: RequestContextParent | undefined;
+    readonly namespace?: (string & Schema2.NonEmptyString255Brand) | undefined;
+    readonly id?: Schema2.StringId;
+    readonly rootId?: string & Schema2.StringIdBrand;
+    readonly createdAt?: Date;
+}, RequestContext, import("effect/Data").Case>;
 /**
  * @tsplus type RequestContext
  * @tsplus companion RequestContext.Ops
  */
 export declare class RequestContext extends RequestContext_base {
-    static inherit(this: void, parent: RequestContext, newSelf: RequestContextParent.ConstructorInput): RequestContext;
+    static inherit(this: void, parent: RequestContext, newSelf: ConstructorParameters<typeof RequestContextParent>[0]): RequestContext;
     static toMonitoring(this: void, self: RequestContext): {
-        parentOperationName?: import("@effect-app/schema").NonEmptyString255 | undefined;
-        parentLocale?: "en" | "de" | undefined;
-        operationName: import("@effect-app/schema").NonEmptyString255;
+        parentOperationName?: string & Schema2.NonEmptyString255Brand;
+        parentLocale?: "en" | "de";
+        operationName: string & Schema2.NonEmptyString255Brand;
         locale: "en" | "de";
     };
 }
 export declare namespace RequestContextParent {
-    const From_base: import("@effect-app/schema").FromClass<{
+    const From_base: Schema2.FromClass<{
         readonly _tag: "RequestContext";
         readonly id: string;
         readonly name: string;
+        readonly locale: "en" | "de";
+        readonly createdAt: string;
         readonly userProfile?: {
             readonly sub: string;
         } | undefined;
-        readonly locale: "en" | "de";
-        readonly createdAt: string;
     }>;
     /**
      * @tsplus type RequestContextParent.From
@@ -89,24 +104,29 @@ export declare namespace RequestContextParent {
      */
     export class From extends From_base {
     }
-    export interface ConstructorInput extends ConstructorInputApi<typeof RequestContextParent> {
-    }
-    export interface Fields extends FieldsClass<typeof RequestContextParent> {
-    }
     export {};
 }
 export declare namespace RequestContext {
-    const From_base_1: import("@effect-app/schema").FromClass<{
+    const From_base_1: Schema2.FromClass<{
         readonly _tag: "RequestContext";
         readonly id: string;
+        readonly rootId: string;
         readonly name: string;
+        readonly locale: "en" | "de";
+        readonly createdAt: string;
         readonly userProfile?: {
             readonly sub: string;
         } | undefined;
-        readonly locale: "en" | "de";
-        readonly createdAt: string;
-        readonly rootId: string;
-        readonly parent?: RequestContextParent.From | undefined;
+        readonly parent?: {
+            readonly _tag: "RequestContext";
+            readonly id: string;
+            readonly name: string;
+            readonly locale: "en" | "de";
+            readonly createdAt: string;
+            readonly userProfile?: {
+                readonly sub: string;
+            } | undefined;
+        } | undefined;
         readonly namespace?: string | undefined;
     }>;
     /**
@@ -115,10 +135,6 @@ export declare namespace RequestContext {
      */
     export class From extends From_base_1 {
     }
-    export interface ConstructorInput extends ConstructorInputApi<typeof RequestContext> {
-    }
-    export interface Fields extends FieldsClass<typeof RequestContext> {
-    }
     export {};
 }
 export {};

package/dist/RequestContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RequestContext.d.ts","sourceRoot":"","sources":["../_src/RequestContext.ts"],"names":[],"mappings":";AAAA,OAAO,EAAa,aAAa,EAAE,MAAM,yBAAyB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElE,qBACa,oBAAqB,SAAQ,yBAYxC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL;;;GAGG;AACH,qBACa,cAAe,SAAQ,mBAWlC;IACA,MAAM,CAAC,OAAO,CACZ,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,oBAAoB,CAAC,gBAAgB;IAUhD,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc;;;;;;CASrD;AAKD,yBAAiB,oBAAoB,CAAC;;;;;;;;;;;IACpC;;;OAGG;IACH,MAAM,OAAO,IAAK,SAAQ,SAAwC;KAAG;IACrE,MAAM,WAAW,gBACf,SAAQ,mBAAmB,CAAC,OAAO,oBAAoB,CAAC;KAAG;IAC7D,MAAM,WAAW,MAAO,SAAQ,WAAW,CAAC,OAAO,oBAAoB,CAAC;KAAG;;CAC5E;AACD,yBAAiB,cAAc,CAAC;;;;;;;;;;;;;;IAC9B;;;OAGG;IACH,MAAM,OAAO,IAAK,SAAQ,WAAkC;KAAG;IAC/D,MAAM,WAAW,gBACf,SAAQ,mBAAmB,CAAC,OAAO,cAAc,CAAC;KAAG;IACvD,MAAM,WAAW,MAAO,SAAQ,WAAW,CAAC,OAAO,cAAc,CAAC;KAAG;;CACtE"}
+{"version":3,"file":"RequestContext.d.ts","sourceRoot":"","sources":["../_src/RequestContext.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAW7C,qBACa,oBAAqB,SAAQ,yBAKxC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL;;;GAGG;AACH,qBACa,cAAe,SAAQ,mBAclC;IACA,MAAM,CAAC,OAAO,CACZ,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,qBAAqB,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC,CAAC;IAUhE,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc;;;;;;CASrD;AAKD,yBAAiB,oBAAoB,CAAC;;;;;;;;;;;IACpC;;;OAGG;IACH,MAAM,OAAO,IAAK,SAAQ,SAAwC;KAAG;;CACtE;AACD,yBAAiB,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;IAC9B;;;OAGG;IACH,MAAM,OAAO,IAAK,SAAQ,WAAkC;KAAG;;CAChE"}