@effect-app/infra 4.0.0-beta.22 → 4.0.0-beta.221

package/src/Store/codeFilter.ts

@@ -1,9 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
-import { Array, Option } from "effect-app"
-import { assertUnreachable, get } from "effect-app/utils"
+import * as Array from "effect-app/Array"
+import * as Option from "effect-app/Option"
+import { assertUnreachable } from "effect-app/utils"
 import type { FilterR, FilterResult } from "../Model/filter/filterApi.js"
 import type { FieldValues } from "../Model/filter/types.js"
+import { get } from "./Memory.js"
 import type { Filter } from "./service.js"
 import { compare, greaterThan, greaterThanExclusive, lowerThan, lowerThanExclusive } from "./utils.js"
 
@@ -186,6 +188,7 @@ export const codeFilter3_ = <E>(state: readonly FilterResult[], sut: E): boolean
   const statements: any[] = [] // must be defined here to be used by eval.
   // always put everything inside a root scope.
   const s = codeFilter3__([{ t: "where-scope", result: state, relation: "some" }], sut, statements, null, false)
+  // oxlint-disable-next-line no-eval
   return eval(s)
 }
 

package/src/Store/index.ts

@@ -1,12 +1,21 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, Layer, Redacted } from "effect-app"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import * as Redacted from "effect/Redacted"
+import type { SqlClient } from "effect/unstable/sql"
 import { CosmosStoreLayer } from "./Cosmos.js"
 import { DiskStoreLayer } from "./Disk.js"
 import { MemoryStoreLive } from "./Memory.js"
 // import { RedisStoreLayer } from "./Redis.js"
+import { RepositoryRegistryLive } from "../Model.js"
 import type { StorageConfig } from "./service.js"
+import { SQLiteStoreLayer } from "./SQL.js"
+import { PgStoreLayer } from "./SQL/Pg.js"
 
-export function StoreMakerLayer(cfg: StorageConfig) {
+export function StoreMakerLayer(
+  cfg: StorageConfig,
+  options?: { makeSqlClientLayer?: (namespace: string) => Layer.Layer<SqlClient.SqlClient> }
+) {
   return Effect
     .sync(() => {
       const storageUrl = Redacted.value(cfg.url)
@@ -19,6 +28,14 @@ export function StoreMakerLayer(cfg: StorageConfig) {
         console.log("Using disk store at " + dir)
         return DiskStoreLayer(cfg, dir)
       }
+      if (storageUrl.startsWith("sqlite://")) {
+        console.log("Using SQLite store")
+        return SQLiteStoreLayer(cfg, options)
+      }
+      if (storageUrl.startsWith("pg://")) {
+        console.log("Using PostgreSQL store")
+        return PgStoreLayer(cfg)
+      }
       // if (storageUrl.startsWith("redis://")) {
       //   console.log("Using Redis store")
       //   return RedisStoreLayer(cfg)
@@ -27,7 +44,7 @@ export function StoreMakerLayer(cfg: StorageConfig) {
       console.log("Using Cosmos DB store")
       return CosmosStoreLayer(cfg)
     })
-    .pipe(Layer.unwrap)
+    .pipe(Layer.unwrap, Layer.merge(RepositoryRegistryLive))
 }
 
 export * from "./service.js"

package/src/Store/service.ts

@@ -1,17 +1,22 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { UniqueKey } from "@azure/cosmos"
-import { Effect, type NonEmptyReadonlyArray, type Option, type Redacted, ServiceMap } from "effect-app"
+import type { NonEmptyReadonlyArray } from "effect-app/Array"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import type * as Option from "effect-app/Option"
+import type * as Redacted from "effect/Redacted"
+import * as Semaphore from "effect/Semaphore"
 import type { OptimisticConcurrencyException } from "../errors.js"
 import type { FilterResult } from "../Model/filter/filterApi.js"
 import type { FieldValues } from "../Model/filter/types.js"
 import type { FieldPath } from "../Model/filter/types/path/index.js"
-import { type RawQuery } from "../Model/query.js"
+import type { ComputedProjectionIrExpression, RawQuery } from "../Model/query.js"
 
 export interface StoreConfig<E> {
   partitionValue: (e?: E) => string
   /**
-   * Primarily used for testing, creating namespaces in the database to separate data e.g to run multiple tests in isolation within the same database
-   * currently only supported in disk/memory. CosmosDB is TODO.
+   * Primarily used for testing, creating namespaces in the database to separate data e.g to run multiple tests in isolation within the same database.
+   * Memory/Disk use separate store instances per namespace. CosmosDB uses namespace-prefixed partition keys. SQL uses a `_namespace` column.
    */
   allowNamespace?: (namespace: string) => boolean
   /**
@@ -60,7 +65,14 @@ export interface O<TFieldValues extends FieldValues> {
 export interface FilterArgs<Encoded extends FieldValues, U extends keyof Encoded = never> {
   t: Encoded
   filter?: Filter | undefined
-  select?: NonEmptyReadonlyArray<U | { key: string; subKeys: readonly string[] }> | undefined
+  select?:
+    | NonEmptyReadonlyArray<
+      U | { key: string; subKeys: readonly string[] } | {
+        key: string
+        computed: ComputedProjectionIrExpression
+      }
+    >
+    | undefined
   order?: NonEmptyReadonlyArray<O<NoInfer<Encoded>>>
   limit?: number | undefined
   skip?: number | undefined
@@ -87,9 +99,14 @@ export interface Store<
   ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException>
   batchRemove: (ids: NonEmptyReadonlyArray<Encoded[IdKey]>, partitionKey?: string) => Effect.Effect<void>
   queryRaw: <Out>(query: RawQuery<Encoded, Out>) => Effect.Effect<readonly Out[]>
+  /**
+   * Explicitly seed a namespace. Primary is seeded eagerly on initialization.
+   * Non-primary namespaces must be seeded explicitly before use.
+   */
+  seedNamespace: (namespace: string) => Effect.Effect<void>
 }
 
-export class StoreMaker extends ServiceMap.Opaque<StoreMaker, {
+export class StoreMaker extends Context.Opaque<StoreMaker, {
   make: <IdKey extends keyof Encoded, Encoded extends FieldValues, R = never, E = never>(
     name: string,
     idKey: IdKey,
@@ -161,16 +178,34 @@ export const makeContextMap = () => {
   //   }
   // }
 
+  const store = new Map<symbol, unknown>()
+  const sem = Semaphore.makeUnsafe(1)
+
   return {
     get: getEtag,
-    set: setEtag
-    // parserEnv
+    set: setEtag,
+    getOrCreateStore: <T>(key: symbol, make: () => T): T => {
+      let value = store.get(key) as T | undefined
+      if (value === undefined) {
+        value = make()
+        store.set(key, value)
+      }
+      return value
+    },
+    getOrCreateStoreEffect: <T, E, R>(key: symbol, make: Effect.Effect<T, E, R>): Effect.Effect<T, E, R> =>
+      sem.withPermits(1)(Effect.uninterruptible(Effect.gen(function*() {
+        const value = store.get(key) as T | undefined
+        if (value !== undefined) return value
+        const v = yield* make
+        store.set(key, v)
+        return v
+      })))
   }
 }
 
 const makeMap = Effect.sync(() => makeContextMap())
 
-export class ContextMap extends ServiceMap.Opaque<ContextMap>()("effect-app/ContextMap", { make: makeMap }) {
+export class ContextMap extends Context.Opaque<ContextMap>()("effect-app/ContextMap", { make: makeMap }) {
 }
 
 export type PersistenceModelType<Encoded extends object> = Encoded & {
@@ -178,7 +213,7 @@ export type PersistenceModelType<Encoded extends object> = Encoded & {
 }
 
 export interface StorageConfig {
-  url: Redacted.Redacted<string>
+  url: Redacted.Redacted
   prefix: string
   dbName: string
 }

package/src/Store/utils.ts

@@ -1,5 +1,6 @@
 import crypto from "crypto"
-import { Effect, Option } from "effect-app"
+import * as Effect from "effect-app/Effect"
+import * as Option from "effect-app/Option"
 import { OptimisticConcurrencyException } from "../errors.js"
 import type { PersistenceModelType, SupportedValues2 } from "./service.js"
 
@@ -12,33 +13,34 @@ export const makeETag = <E extends PersistenceModelType<{}>>(
     _etag: crypto.createHash("sha256").update(JSON.stringify(e)).digest("hex")
   }) as any
 
-export const makeUpdateETag =
-  (type: string) =>
-  <IdKey extends keyof E, E extends PersistenceModelType<{}>>(e: E, idKey: IdKey, current: Option.Option<E>) =>
-    Effect.gen(function*() {
-      if (e._etag) {
-        if (Option.isNone(current)) {
-          return yield* new OptimisticConcurrencyException({
-            type,
-            id: e[idKey] as string,
-            current: "",
-            found: e._etag,
-            code: 409
-          })
-        }
-      }
-      if (Option.isSome(current) && current.value._etag !== e._etag) {
+export const makeUpdateETag = (type: string) =>
+  Effect.fnUntraced(function*<IdKey extends keyof E, E extends PersistenceModelType<{}>>(
+    e: E,
+    idKey: IdKey,
+    current: Option.Option<E>
+  ) {
+    if (e._etag) {
+      if (Option.isNone(current)) {
         return yield* new OptimisticConcurrencyException({
           type,
-          id: current.value[idKey] as string,
-          current: current.value._etag,
+          id: e[idKey] as string,
+          current: "",
           found: e._etag,
-          code: 412
+          code: 409
         })
       }
-      const newE = makeETag(e)
-      return newE
-    })
+    }
+    if (Option.isSome(current) && current.value._etag !== e._etag) {
+      return yield* new OptimisticConcurrencyException({
+        type,
+        id: current.value[idKey] as string,
+        current: current.value._etag,
+        found: e._etag,
+        code: 412
+      })
+    }
+    return makeETag(e)
+  })
 
 export function lowercaseIfString<T>(val: T) {
   if (typeof val === "string") {

package/src/adapters/SQL/Model.ts

@@ -24,6 +24,7 @@ import * as VariantSchema from "effect/unstable/schema/VariantSchema"
 import { SqlClient } from "effect/unstable/sql/SqlClient"
 import * as SqlResolver from "effect/unstable/sql/SqlResolver"
 import * as SqlSchema from "effect/unstable/sql/SqlSchema"
+import { type DbSystem, withDbSpan } from "../../otel.js"
 
 const {
   Class,
@@ -73,7 +74,7 @@ export {
    * @since 1.0.0
    * @category constructors
    * @example
-   * import { Schema } from "effect"
+   * import * as Schema from "effect/Schema"
    * import { Model } from "effect/unstable/schema"
    *
    * export const GroupId = Schema.Number.pipe(Schema.brand("GroupId"))
@@ -545,9 +546,15 @@ export const DateTimeUpdateFromNumber: DateTimeUpdateFromNumber = Field({
  */
 export interface JsonFromString<S extends Schema.Top> extends
   VariantSchema.Field<{
-    readonly select: Schema.fromJsonString<S>
-    readonly insert: Schema.fromJsonString<S>
-    readonly update: Schema.fromJsonString<S>
+    readonly select: Schema.fromJsonString<
+      Schema.Codec<S["Type"], Schema.Json, S["DecodingServices"], S["EncodingServices"]>
+    >
+    readonly insert: Schema.fromJsonString<
+      Schema.Codec<S["Type"], Schema.Json, S["DecodingServices"], S["EncodingServices"]>
+    >
+    readonly update: Schema.fromJsonString<
+      Schema.Codec<S["Type"], Schema.Json, S["DecodingServices"], S["EncodingServices"]>
+    >
     readonly json: S
     readonly jsonCreate: S
     readonly jsonUpdate: S
@@ -565,7 +572,7 @@ export interface JsonFromString<S extends Schema.Top> extends
 export const JsonFromString = <S extends Schema.Top>(
   schema: S
 ): JsonFromString<S> => {
-  const parsed = Schema.fromJsonString(schema)
+  const parsed = Schema.fromJsonString(Schema.toCodecJson(schema))
   return Field({
     select: parsed,
     insert: parsed,
@@ -590,6 +597,7 @@ export const makeRepository = <
   readonly spanPrefix: string
   readonly idColumn: Id
   readonly versionColumn?: string | undefined
+  readonly dbSystem?: DbSystem | undefined
 }): Effect.Effect<
   {
     readonly insert: (
@@ -623,6 +631,15 @@ export const makeRepository = <
     const idSchema = Model.fields[options.idColumn] as Schema.Top
     const idColumn = options.idColumn as string
     const versionColumn = options.versionColumn
+    const system: DbSystem = options.dbSystem ?? "other_sql"
+    const opSpan = (operation: string, idValue?: unknown) =>
+      withDbSpan({
+        operation,
+        system,
+        collection: options.tableName,
+        entity: options.spanPrefix,
+        ...(idValue !== undefined && { extra: { "app.entity.id": idValue } })
+      })
 
     const insertSchema = SqlSchema.findOne({
       Request: Model.insert,
@@ -644,9 +661,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
     ): Effect.Effect<S["Type"], Schema.SchemaError, S["DecodingServices"] | S["insert"]["EncodingServices"]> =>
       insertSchema(insert).pipe(
         Effect.catchTag("NoSuchElementError", Effect.die),
-        Effect.withSpan(`${options.spanPrefix}.insert`, {}, {
-          captureStackTrace: false
-        })
+        opSpan("insert")
       ) as any
 
     const insertVoidSchema = SqlSchema.void({
@@ -657,9 +672,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
       insert: S["insert"]["Type"]
     ): Effect.Effect<void, Schema.SchemaError, S["insert"]["EncodingServices"]> =>
       insertVoidSchema(insert).pipe(
-        Effect.withSpan(`${options.spanPrefix}.insertVoid`, {}, {
-          captureStackTrace: false
-        })
+        opSpan("insertVoid")
       ) as any
 
     const updateSchema = SqlSchema.findOne({
@@ -706,11 +719,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
     ): Effect.Effect<S["Type"], Schema.SchemaError, S["DecodingServices"] | S["update"]["EncodingServices"]> =>
       updateSchema(update).pipe(
         Effect.catchTag("NoSuchElementError", Effect.die),
-        Effect.withSpan(`${options.spanPrefix}.update`, {
-          attributes: { id: (update as any)[idColumn] }
-        }, {
-          captureStackTrace: false
-        })
+        opSpan("update", (update as any)[idColumn])
       ) as any
 
     const updateVoidSchema = SqlSchema.void({
@@ -729,11 +738,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
       update: S["update"]["Type"]
     ): Effect.Effect<void, Schema.SchemaError, S["update"]["EncodingServices"]> =>
       updateVoidSchema(update).pipe(
-        Effect.withSpan(`${options.spanPrefix}.updateVoid`, {
-          attributes: { id: (update as any)[idColumn] }
-        }, {
-          captureStackTrace: false
-        })
+        opSpan("updateVoid", (update as any)[idColumn])
       ) as any
 
     const findByIdSchema = SqlSchema.findOneOption({
@@ -749,9 +754,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
       S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
     > =>
       findByIdSchema(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.findById`, { attributes: { id } }, {
-          captureStackTrace: false
-        })
+        opSpan("findById", id)
       ) as any
 
     const deleteSchema = SqlSchema.void({
@@ -762,11 +765,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
       id: S["fields"][Id]["Type"]
     ): Effect.Effect<void, Schema.SchemaError, S["fields"][Id]["EncodingServices"]> =>
       deleteSchema(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.delete`, {
-          attributes: { id }
-        }, {
-          captureStackTrace: false
-        })
+        opSpan("delete", id)
       ) as any
 
     return { insert, insertVoid, update, updateVoid, findById, delete: delete_ } as const
@@ -789,6 +788,7 @@ export const makeDataLoaders = <
     readonly idColumn: Id
     readonly window: Input
     readonly maxBatchSize?: number | undefined
+    readonly dbSystem?: DbSystem | undefined
   }
 ): Effect.Effect<
   {
@@ -821,6 +821,15 @@ export const makeDataLoaders = <
     const idSchema = Model.fields[options.idColumn] as Schema.Top
     const idColumn = options.idColumn as string
     const setMaxBatchSize = options.maxBatchSize ? RequestResolver.batchN(options.maxBatchSize) : identity
+    const system: DbSystem = options.dbSystem ?? "other_sql"
+    const opSpan = (operation: string, idValue?: unknown) =>
+      withDbSpan({
+        operation,
+        system,
+        collection: options.tableName,
+        entity: options.spanPrefix,
+        ...(idValue !== undefined && { extra: { "app.entity.id": idValue } })
+      })
 
     const insertResolver = SqlResolver
       .ordered({
@@ -854,9 +863,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
     > =>
       insertExecute(insert).pipe(
         Effect.catchTag("ResultLengthMismatch", Effect.die),
-        Effect.withSpan(`${options.spanPrefix}.insert`, {}, {
-          captureStackTrace: false
-        })
+        opSpan("insert")
       ) as any
 
     const insertVoidResolver = SqlResolver
@@ -874,9 +881,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
       insert: S["insert"]["Type"]
     ): Effect.Effect<void, Schema.SchemaError, S["insert"]["EncodingServices"]> =>
       insertVoidExecute(insert).pipe(
-        Effect.withSpan(`${options.spanPrefix}.insertVoid`, {}, {
-          captureStackTrace: false
-        })
+        opSpan("insertVoid")
       ) as any
 
     const findByIdResolver = SqlResolver
@@ -902,9 +907,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
       S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
     > =>
       findByIdExecute(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.findById`, { attributes: { id } }, {
-          captureStackTrace: false
-        })
+        opSpan("findById", id)
       ) as any
 
     const deleteResolver = SqlResolver
@@ -922,9 +925,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
       id: S["fields"][Id]["Type"]
     ): Effect.Effect<void, Schema.SchemaError, S["fields"][Id]["EncodingServices"]> =>
       deleteExecute(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.delete`, { attributes: { id } }, {
-          captureStackTrace: false
-        })
+        opSpan("delete", id)
       ) as any
 
     return { insert, insertVoid, findById, delete: delete_ } as const