effect 4.0.0-beta.42 → 4.0.0-beta.44

package/src/unstable/persistence/KeyValueStore.ts

@@ -1,6 +1,7 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import * as Encoding from "../../Encoding.ts"
@@ -13,8 +14,9 @@ import type { PlatformError } from "../../PlatformError.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Result from "../../Result.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as UndefinedOr from "../../UndefinedOr.ts"
+import * as SqlClient from "../sql/SqlClient.ts"
+import type { SqlError } from "../sql/SqlError.ts"
 
 const TypeId = "~effect/persistence/KeyValueStore" as const
 
@@ -170,10 +172,10 @@ export class KeyValueStoreError extends Data.TaggedError("KeyValueStoreError")<{
  * @since 4.0.0
  * @category tags
  */
-export const KeyValueStore: ServiceMap.Service<
+export const KeyValueStore: Context.Service<
   KeyValueStore,
   KeyValueStore
-> = ServiceMap.Service("effect/persistence/KeyValueStore")
+> = Context.Service("effect/persistence/KeyValueStore")
 
 /**
  * @since 4.0.0
@@ -391,6 +393,227 @@ export const layerFileSystem = (
     })
   }))
 
+/**
+ * @since 4.0.0
+ * @category layers
+ */
+export interface LayerSqlOptions {
+  /**
+   * The SQL table name used to store values.
+   *
+   * @default "effect_key_value_store"
+   */
+  readonly table?: string
+}
+
+/**
+ * @since 4.0.0
+ * @category layers
+ */
+export const layerSql = (
+  options: LayerSqlOptions = {}
+): Layer.Layer<KeyValueStore, never, SqlClient.SqlClient> =>
+  Layer.effect(KeyValueStore)(
+    Effect.gen(function*() {
+      const sql = (yield* SqlClient.SqlClient).withoutTransforms()
+      const table = sql(options.table ?? "effect_key_value_store")
+
+      yield* sql.onDialectOrElse({
+        mysql: () =>
+          sql`
+          CREATE TABLE IF NOT EXISTS ${table} (
+            id VARCHAR(191) PRIMARY KEY,
+            value BLOB NOT NULL,
+            value_type SMALLINT NOT NULL
+          )
+        `,
+        pg: () =>
+          sql`
+          CREATE TABLE IF NOT EXISTS ${table} (
+            id TEXT PRIMARY KEY,
+            value BYTEA NOT NULL,
+            value_type SMALLINT NOT NULL
+          )
+        `,
+        mssql: () =>
+          sql`
+          IF NOT EXISTS (SELECT * FROM sysobjects WHERE name=${table} AND xtype='U')
+          CREATE TABLE ${table} (
+            id NVARCHAR(450) PRIMARY KEY,
+            value VARBINARY(MAX) NOT NULL,
+            value_type SMALLINT NOT NULL
+          )
+        `,
+        // sqlite
+        orElse: () =>
+          sql`
+          CREATE TABLE IF NOT EXISTS ${table} (
+            id TEXT PRIMARY KEY,
+            value BLOB NOT NULL,
+            value_type INTEGER NOT NULL
+          )
+        `
+      }).pipe(Effect.orDie)
+
+      type UpsertFn = (entry: {
+        id: string
+        value: Uint8Array
+        value_type: number
+      }) => Effect.Effect<unknown, SqlError>
+
+      const upsert = sql.onDialectOrElse({
+        pg: (): UpsertFn => (entry) =>
+          sql`
+          INSERT INTO ${table} (id, value, value_type) VALUES (${entry.id}, ${entry.value}, ${entry.value_type})
+          ON CONFLICT (id) DO UPDATE SET value=EXCLUDED.value, value_type=EXCLUDED.value_type
+        `.unprepared,
+        mysql: (): UpsertFn => (entry) =>
+          sql`
+          INSERT INTO ${table} (id, value, value_type) VALUES (${entry.id}, ${entry.value}, ${entry.value_type})
+          ON DUPLICATE KEY UPDATE value=VALUES(value), value_type=VALUES(value_type)
+        `,
+        mssql: (): UpsertFn => (entry) =>
+          sql`
+          MERGE ${table} AS target
+          USING (SELECT ${entry.id} AS id, ${entry.value} AS value, ${entry.value_type} AS value_type) AS source
+          ON target.id = source.id
+          WHEN MATCHED THEN UPDATE SET value = source.value, value_type = source.value_type
+          WHEN NOT MATCHED THEN INSERT (id, value, value_type)
+          VALUES (source.id, source.value, source.value_type);
+        `,
+        // sqlite
+        orElse: (): UpsertFn => (entry) =>
+          sql`
+          INSERT INTO ${table} (id, value, value_type) VALUES (${entry.id}, ${entry.value}, ${entry.value_type})
+          ON CONFLICT(id) DO UPDATE SET value=excluded.value, value_type=excluded.value_type
+        `.unprepared
+      })
+
+      const encoder = new TextEncoder()
+      const decoder = new TextDecoder()
+      const ValueTypeString = 0
+      const ValueTypeUint8Array = 1
+
+      type Row = {
+        value: Uint8Array
+        value_type: number
+      }
+
+      return make({
+        get: (key: string) =>
+          sql<Row>`SELECT value, value_type FROM ${table} WHERE id = ${key}`.pipe(
+            Effect.mapError((cause) =>
+              new KeyValueStoreError({
+                method: "get",
+                key,
+                message: `Unable to get item with key ${key}`,
+                cause
+              })
+            ),
+            Effect.flatMap((rows) => {
+              if (rows.length === 0) {
+                return Effect.undefined
+              }
+              const row = rows[0]
+              switch (row.value_type) {
+                case ValueTypeString:
+                  return Effect.succeed(decoder.decode(row.value))
+                case ValueTypeUint8Array:
+                  return Effect.succeed(Encoding.encodeBase64(row.value))
+                default:
+                  return Effect.fail(
+                    new KeyValueStoreError({
+                      method: "get",
+                      key,
+                      message: `Invalid stored value type for key ${key}: ${row.value_type}`
+                    })
+                  )
+              }
+            })
+          ),
+        getUint8Array: (key: string) =>
+          sql<Row>`SELECT value, value_type FROM ${table} WHERE id = ${key}`.pipe(
+            Effect.mapError((cause) =>
+              new KeyValueStoreError({
+                method: "getUint8Array",
+                key,
+                message: `Unable to get item with key ${key}`,
+                cause
+              })
+            ),
+            Effect.flatMap((rows) => {
+              if (rows.length === 0) {
+                return Effect.undefined
+              }
+              const row = rows[0]
+              switch (row.value_type) {
+                case ValueTypeString:
+                  return Effect.succeed(row.value)
+                case ValueTypeUint8Array:
+                  return Effect.succeed(row.value)
+                default:
+                  return Effect.fail(
+                    new KeyValueStoreError({
+                      method: "getUint8Array",
+                      key,
+                      message: `Invalid stored value type for key ${key}: ${row.value_type}`
+                    })
+                  )
+              }
+            })
+          ),
+        set: (key: string, value: string | Uint8Array) =>
+          upsert({
+            id: key,
+            value: typeof value === "string" ? encoder.encode(value) : value,
+            value_type: typeof value === "string" ? ValueTypeString : ValueTypeUint8Array
+          }).pipe(
+            Effect.mapError((cause) =>
+              new KeyValueStoreError({
+                method: "set",
+                key,
+                message: `Unable to set item with key ${key}`,
+                cause
+              })
+            ),
+            Effect.asVoid
+          ),
+        remove: (key: string) =>
+          sql`DELETE FROM ${table} WHERE id = ${key}`.pipe(
+            Effect.mapError((cause) =>
+              new KeyValueStoreError({
+                method: "remove",
+                key,
+                message: `Unable to remove item with key ${key}`,
+                cause
+              })
+            ),
+            Effect.asVoid
+          ),
+        clear: sql`DELETE FROM ${table}`.pipe(
+          Effect.mapError((cause) =>
+            new KeyValueStoreError({
+              method: "clear",
+              message: `Unable to clear storage`,
+              cause
+            })
+          ),
+          Effect.asVoid
+        ),
+        size: sql<{ count: number }>`SELECT COUNT(*) as count FROM ${table}`.pipe(
+          Effect.mapError((cause) =>
+            new KeyValueStoreError({
+              method: "size",
+              message: `Unable to get size`,
+              cause
+            })
+          ),
+          Effect.map((rows) => rows.length === 0 ? 0 : Number(rows[0].count))
+        )
+      })
+    })
+  )
+
 const SchemaStoreTypeId = "~effect/persistence/KeyValueStore/SchemaStore" as const
 
 /**

package/src/unstable/persistence/PersistedCache.ts

@@ -41,9 +41,8 @@ export const make: <
   K extends Persistable.Any,
   R = never,
   ServiceMode extends "lookup" | "construction" = never
->(options: {
+>(lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>, options: {
   readonly storeId: string
-  readonly lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>
   readonly timeToLive: Persistable.TimeToLiveFn<K>
   readonly inMemoryCapacity?: number | undefined
   readonly inMemoryTTL?: Persistable.TimeToLiveFn<K> | undefined
@@ -56,32 +55,36 @@ export const make: <
   K extends Persistable.Any,
   R = never,
   ServiceMode extends "lookup" | "construction" = never
->(options: {
-  readonly storeId: string
-  readonly lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>
-  readonly timeToLive: Persistable.TimeToLiveFn<K>
-  readonly inMemoryCapacity?: number | undefined
-  readonly inMemoryTTL?: Persistable.TimeToLiveFn<K> | undefined
-  readonly requireServicesAt?: ServiceMode | undefined
-}) {
+>(
+  lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>,
+  options: {
+    readonly storeId: string
+    readonly timeToLive: Persistable.TimeToLiveFn<K>
+    readonly inMemoryCapacity?: number | undefined
+    readonly inMemoryTTL?: Persistable.TimeToLiveFn<K> | undefined
+    readonly requireServicesAt?: ServiceMode | undefined
+  }
+) {
   const store = yield* (yield* Persistence.Persistence).make({
     storeId: options.storeId,
     timeToLive: options.timeToLive as any
   })
-  const inMemory = yield* Cache.makeWith({
-    lookup: Effect.fnUntraced(function*(key: K) {
+  const inMemory = yield* Cache.makeWith(
+    Effect.fnUntraced(function*(key: K) {
       const exit = yield* (store.get(key) as Effect.Effect<Exit<Persistable.Success<K>, Persistable.Error<K>>>)
       if (exit) {
         return yield* exit
       }
-      const result = yield* Effect.exit(options.lookup(key))
+      const result = yield* Effect.exit(lookup(key))
       yield* (store.set(key, result) as Effect.Effect<void>)
       return yield* result
     }),
-    timeToLive: options.inMemoryTTL ?? constant(Duration.seconds(10)),
-    capacity: options.inMemoryCapacity ?? 1024,
-    requireServicesAt: options.requireServicesAt
-  })
+    {
+      timeToLive: options.inMemoryTTL ?? constant(Duration.seconds(10)),
+      capacity: options.inMemoryCapacity ?? 1024,
+      requireServicesAt: options.requireServicesAt
+    }
+  )
   return identity<PersistedCache<K, "lookup" extends ServiceMode ? R : never>>({
     [TypeId]: TypeId,
     inMemory,

package/src/unstable/persistence/PersistedQueue.ts

@@ -3,6 +3,7 @@
  */
 import type * as Arr from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
@@ -17,7 +18,6 @@ import * as RcMap from "../../RcMap.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as SqlClient from "../sql/SqlClient.ts"
 import type { SqlError } from "../sql/SqlError.ts"
 import * as Redis from "./Redis.ts"
@@ -75,7 +75,7 @@ export interface PersistedQueue<in out A, out R = never> {
  * @since 4.0.0
  * @category Factory
  */
-export class PersistedQueueFactory extends ServiceMap.Service<
+export class PersistedQueueFactory extends Context.Service<
   PersistedQueueFactory,
   {
     readonly make: <S extends Schema.Top>(options: {
@@ -195,7 +195,7 @@ export class PersistedQueueError extends Schema.ErrorClass<PersistedQueueError>(
  * @since 4.0.0
  * @category Store
  */
-export class PersistedQueueStore extends ServiceMap.Service<
+export class PersistedQueueStore extends Context.Service<
   PersistedQueueStore,
   {
     readonly offer: (

package/src/unstable/persistence/Persistence.ts

@@ -3,6 +3,7 @@
  */
 import * as Arr from "../../Array.ts"
 import * as Clock from "../../Clock.ts"
+import * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
@@ -11,7 +12,6 @@ import * as Layer from "../../Layer.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
 import * as Schema from "../../Schema.ts"
 import type * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as SqlClient from "../sql/SqlClient.ts"
 import type { SqlError } from "../sql/SqlError.ts"
 import * as KeyValueStore from "./KeyValueStore.ts"
@@ -24,7 +24,7 @@ const ErrorTypeId = "~effect/persistence/Persistence/PersistenceError" as const
  * @since 4.0.0
  * @category errors
  */
-export class PersistenceError extends Schema.ErrorClass(ErrorTypeId)({
+export class PersistenceError extends Schema.ErrorClass<PersistenceError>(ErrorTypeId)({
   _tag: Schema.tag("PersistenceError"),
   message: Schema.String,
   cause: Schema.optional(Schema.Defect)
@@ -39,7 +39,7 @@ export class PersistenceError extends Schema.ErrorClass(ErrorTypeId)({
  * @since 4.0.0
  * @category Models
  */
-export class Persistence extends ServiceMap.Service<Persistence, {
+export class Persistence extends Context.Service<Persistence, {
   readonly make: (options: {
     readonly storeId: string
     readonly timeToLive?: (exit: Exit.Exit<unknown, unknown>, key: Persistable.Any) => Duration.Input
@@ -82,7 +82,7 @@ export interface PersistenceStore {
  * @since 4.0.0
  * @category BackingPersistence
  */
-export class BackingPersistence extends ServiceMap.Service<BackingPersistence, {
+export class BackingPersistence extends Context.Service<BackingPersistence, {
   readonly make: (storeId: string) => Effect.Effect<BackingPersistenceStore, never, Scope.Scope>
 }>()("effect/persistence/BackingPersistence") {}
 

package/src/unstable/persistence/RateLimiter.ts

@@ -2,12 +2,12 @@
  * @since 4.0.0
  */
 import * as Config from "../../Config.ts"
+import * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import { flow, identity } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Redis from "./Redis.ts"
 
 /**
@@ -43,7 +43,7 @@ export interface RateLimiter {
  * @since 4.0.0
  * @category Tags
  */
-export const RateLimiter: ServiceMap.Service<RateLimiter, RateLimiter> = ServiceMap.Service<RateLimiter>(TypeId)
+export const RateLimiter: Context.Service<RateLimiter, RateLimiter> = Context.Service<RateLimiter>(TypeId)
 
 /**
  * @since 4.0.0
@@ -413,7 +413,7 @@ export interface ConsumeResult {
  * @since 4.0.0
  * @category RateLimiterStore
  */
-export class RateLimiterStore extends ServiceMap.Service<
+export class RateLimiterStore extends Context.Service<
   RateLimiterStore,
   {
     /**

package/src/unstable/persistence/Redis.ts

@@ -2,18 +2,18 @@
  * @since 4.0.0
  */
 import * as Cache from "../../Cache.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Equal from "../../Equal.ts"
 import { constant, identity } from "../../Function.ts"
 import * as Hash from "../../Hash.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 
 /**
  * @since 4.0.0
  * @category Service
  */
-export class Redis extends ServiceMap.Service<Redis, {
+export class Redis extends Context.Service<Redis, {
   readonly send: <A = unknown>(command: string, ...args: ReadonlyArray<string>) => Effect.Effect<A, RedisError>
 
   readonly eval: <

package/src/unstable/process/ChildProcessSpawner.ts

@@ -7,11 +7,11 @@
  * @since 4.0.0
  */
 import * as Brand from "../../Brand.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Inspectable from "../../Inspectable.ts"
 import type * as PlatformError from "../../PlatformError.ts"
 import type * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Sink from "../../Sink.ts"
 import * as Stream from "../../Stream.ts"
 import type { Command, KillOptions } from "./ChildProcess.ts"
@@ -40,6 +40,19 @@ export type ProcessId = Brand.Branded<number, "ProcessId">
  */
 export const ProcessId: Brand.Constructor<ProcessId> = Brand.nominal<ProcessId>()
 
+/**
+ * An `Effect` that adds an unrefed child process back into the parent
+ * process's reference count.
+ *
+ * This value is returned by `ChildProcessHandle.unref` and can be run later to
+ * restore the default behavior where the child process keeps the parent
+ * process alive.
+ *
+ * @since 4.0.0
+ * @category Models
+ */
+export type Reref = Effect.Effect<void, PlatformError.PlatformError>
+
 const HandleTypeId = "~effect/ChildProcessSpawner/ChildProcessHandle"
 
 /**
@@ -109,6 +122,37 @@ export interface ChildProcessHandle {
    * `Stream`.
    */
   readonly getOutputFd: (fd: number) => Stream.Stream<Uint8Array, PlatformError.PlatformError>
+  /**
+   * Allows the parent process to exit independently of this child process.
+   *
+   * Running this `Effect` removes this child process from the parent process's
+   * reference count, so the parent process is allowed to exit without waiting
+   * for the child process to finish.
+   *
+   * The returned `Reref` effect adds the child process back into the parent
+   * process's reference count when run, restoring the default behavior.
+   *
+   * This is the only supported way to re-reference a child process after it
+   * has been unrefed.
+   *
+   * @example
+   * ```ts
+   * import { NodeServices } from "@effect/platform-node"
+   * import { Effect } from "effect"
+   * import { ChildProcess } from "effect/unstable/process"
+   *
+   * const program = Effect.gen(function*() {
+   *   const handle = yield* ChildProcess.make`./server`
+   *   const reref = yield* handle.unref
+   *
+   *   yield* Effect.sleep("1 second")
+   *
+   *   yield* reref
+   *   return yield* handle.exitCode
+   * }).pipe(Effect.scoped, Effect.provide(NodeServices.layer))
+   * ```
+   */
+  readonly unref: Effect.Effect<Reref, PlatformError.PlatformError>
 }
 
 const HandleProto = {
@@ -163,7 +207,7 @@ export const make = (spawn: ChildProcessSpawner["Service"]["spawn"]): ChildProce
  * @since 4.0.0
  * @category Service
  */
-export class ChildProcessSpawner extends ServiceMap.Service<ChildProcessSpawner, {
+export class ChildProcessSpawner extends Context.Service<ChildProcessSpawner, {
   /**
    * Spawn a command and return a handle for interaction.
    */