@effect/platform-browser 4.0.0-beta.6 → 4.0.0-beta.60

package/src/BrowserPersistence.ts

@@ -0,0 +1,303 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Arr from "effect/Array"
+import * as Clock from "effect/Clock"
+import type * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Persistence from "effect/unstable/persistence/Persistence"
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerBackingIndexedDb = (options?: {
+  readonly database?: string | undefined
+}): Layer.Layer<Persistence.BackingPersistence> =>
+  Layer.effect(Persistence.BackingPersistence)(Effect.gen(function*() {
+    const db = yield* Effect.acquireRelease(
+      openDatabase(options?.database ?? defaultDatabase),
+      (db) => Effect.sync(() => db.close())
+    ).pipe(Effect.orDie)
+
+    return Persistence.BackingPersistence.of({
+      make: Effect.fnUntraced(function*(storeId) {
+        const clock = yield* Clock.Clock
+        return {
+          get: (key) => get(db, clock, storeId, key),
+          getMany: (keys) => getMany(db, clock, storeId, keys),
+          set: (key, value, ttl) => set(db, clock, storeId, key, value, ttl),
+          setMany: (entries) => setMany(db, clock, storeId, entries),
+          remove: (key) => remove(db, storeId, key),
+          clear: clear(db, storeId)
+        }
+      })
+    })
+  }))
+
+const defaultDatabase = "effect_persistence"
+const databaseVersion = 1
+const entriesStoreName = "entries"
+const storeIdIndexName = "storeId"
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerIndexedDb = (options?: {
+  readonly database?: string | undefined
+}): Layer.Layer<Persistence.Persistence> =>
+  Persistence.layer.pipe(
+    Layer.provide(layerBackingIndexedDb(options))
+  )
+
+const openDatabase = (database: string): Effect.Effect<IDBDatabase, Persistence.PersistenceError> =>
+  Effect.gen(function*() {
+    const openRequest = yield* Effect.try({
+      try: () => globalThis.indexedDB.open(database, databaseVersion),
+      catch: (cause) =>
+        new Persistence.PersistenceError({
+          message: "Failed to open backing store database",
+          cause
+        })
+    })
+
+    openRequest.onupgradeneeded = () => {
+      const db = openRequest.result
+      const entries = db.objectStoreNames.contains(entriesStoreName)
+        ? openRequest.transaction?.objectStore(entriesStoreName)
+        : db.createObjectStore(entriesStoreName, { keyPath: ["storeId", "id"] })
+      if (entries && !entries.indexNames.contains(storeIdIndexName)) {
+        entries.createIndex(storeIdIndexName, storeIdIndexName, { unique: false })
+      }
+    }
+
+    return yield* idbRequest("Failed to open backing store database", () => openRequest)
+  })
+
+interface EntryRow {
+  readonly storeId: string
+  readonly id: string
+  readonly value: object
+  readonly expires: number | null
+}
+
+const isExpired = (row: EntryRow, now: number): boolean => row.expires !== null && row.expires <= now
+
+const get = (
+  db: IDBDatabase,
+  clock: Clock.Clock,
+  storeId: string,
+  key: string
+): Effect.Effect<object | undefined, Persistence.PersistenceError> =>
+  withEntriesTransaction<object | undefined>(
+    db,
+    "readwrite",
+    `Failed to get key ${key} from backing store`,
+    (
+      entries,
+      setResult,
+      fail
+    ) => {
+      const now = clock.currentTimeMillisUnsafe()
+      const id: [string, string] = [storeId, key]
+      const request = entries.get(id)
+      request.onerror = () => fail(request.error)
+      request.onsuccess = () => {
+        const row = request.result as EntryRow | undefined
+        if (!row || !isExpired(row, now)) {
+          setResult(row?.value)
+          return
+        }
+
+        const deleteRequest = entries.delete(id)
+        deleteRequest.onerror = () => fail(deleteRequest.error)
+        deleteRequest.onsuccess = () => setResult(undefined)
+      }
+    }
+  )
+
+const getMany = (
+  db: IDBDatabase,
+  clock: Clock.Clock,
+  storeId: string,
+  keys: Arr.NonEmptyArray<string>
+): Effect.Effect<Arr.NonEmptyArray<object | undefined>, Persistence.PersistenceError> =>
+  withEntriesTransaction(
+    db,
+    "readwrite",
+    "Failed to getMany from backing store",
+    (entries, setResult, fail) => {
+      const now = clock.currentTimeMillisUnsafe()
+      const results = new Array<object | undefined>(keys.length)
+      setResult(results as any)
+
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i]
+        const keyPath = [storeId, key]
+        const request = entries.get(keyPath)
+        request.onerror = () => fail(request.error)
+        request.onsuccess = () => {
+          const row = request.result as EntryRow | undefined
+          if (!row) return
+          else if (!isExpired(row, now)) {
+            results[i] = row.value
+            return
+          }
+          const deleteRequest = entries.delete(keyPath)
+          deleteRequest.onerror = () => fail(deleteRequest.error)
+        }
+      }
+    }
+  )
+
+const set = (
+  db: IDBDatabase,
+  clock: Clock.Clock,
+  storeId: string,
+  key: string,
+  value: object,
+  ttl: Duration.Duration | undefined
+): Effect.Effect<void, Persistence.PersistenceError> =>
+  withEntriesTransaction(
+    db,
+    "readwrite",
+    `Failed to set key ${key} in backing store`,
+    (entries, setResult, fail) => {
+      const request = entries.put(
+        {
+          storeId,
+          id: key,
+          value,
+          expires: Persistence.unsafeTtlToExpires(clock, ttl)
+        } satisfies EntryRow
+      )
+      request.onerror = () => fail(request.error)
+      request.onsuccess = () => setResult(undefined)
+    }
+  )
+
+const setMany = (
+  db: IDBDatabase,
+  clock: Clock.Clock,
+  storeId: string,
+  entries: Arr.NonEmptyArray<readonly [key: string, value: object, ttl: Duration.Duration | undefined]>
+): Effect.Effect<void, Persistence.PersistenceError> =>
+  withEntriesTransaction(
+    db,
+    "readwrite",
+    "Failed to setMany in backing store",
+    (store, setResult, fail) => {
+      for (const [key, value, ttl] of entries) {
+        const request = store.put(
+          {
+            storeId,
+            id: key,
+            value,
+            expires: Persistence.unsafeTtlToExpires(clock, ttl)
+          } satisfies EntryRow
+        )
+        request.onerror = () => fail(request.error)
+        request.onsuccess = () => setResult(undefined)
+      }
+    }
+  )
+
+const remove = (
+  db: IDBDatabase,
+  storeId: string,
+  key: string
+): Effect.Effect<void, Persistence.PersistenceError> =>
+  withEntriesTransaction(
+    db,
+    "readwrite",
+    `Failed to remove key ${key} from backing store`,
+    (entries, setResult, fail) => {
+      const request = entries.delete([storeId, key])
+      request.onerror = () => fail(request.error)
+      request.onsuccess = () => setResult(undefined)
+    }
+  )
+
+const clear = (db: IDBDatabase, storeId: string): Effect.Effect<void, Persistence.PersistenceError> =>
+  withEntriesTransaction(db, "readwrite", "Failed to clear backing store", (entries, setResult, fail) => {
+    const index = entries.index(storeIdIndexName)
+    const cursorRequest = index.openCursor(storeId)
+    cursorRequest.onerror = () => fail(cursorRequest.error)
+    cursorRequest.onsuccess = () => {
+      const cursor = cursorRequest.result
+      if (!cursor) {
+        setResult(undefined)
+        return
+      }
+      const deleteRequest = cursor.delete()
+      deleteRequest.onerror = () => fail(deleteRequest.error)
+      deleteRequest.onsuccess = () => cursor.continue()
+    }
+  })
+
+const withEntriesTransaction = <A>(
+  db: IDBDatabase,
+  mode: IDBTransactionMode,
+  message: string,
+  run: (
+    entries: IDBObjectStore,
+    onResult: (result: A) => void,
+    fail: (cause: unknown) => void
+  ) => void
+): Effect.Effect<A, Persistence.PersistenceError> =>
+  Effect.callback<A, Persistence.PersistenceError>((resume) => {
+    const tx = db.transaction(entriesStoreName, mode)
+    const entries = tx.objectStore(entriesStoreName)
+
+    let result: A | undefined
+    let setResult = false
+    let done = false
+
+    const fail = (cause: unknown) => {
+      done = true
+      resume(Effect.fail(new Persistence.PersistenceError({ message, cause })))
+    }
+
+    tx.oncomplete = () => {
+      done = true
+      if (setResult) resume(Effect.succeed(result!))
+    }
+    tx.onerror = () => {
+      done = true
+      fail(tx.error)
+    }
+    tx.onabort = () => {
+      done = true
+      fail(tx.error)
+    }
+
+    run(entries, (next) => {
+      if (done) return resume(Effect.succeed(next))
+      setResult = true
+      result = next
+    }, fail)
+
+    return Effect.sync(() => {
+      tx.abort()
+    })
+  })
+
+const idbRequest = <A>(
+  message: string,
+  evaluate: () => IDBRequest<A>
+): Effect.Effect<A, Persistence.PersistenceError> =>
+  Effect.callback<A, Persistence.PersistenceError>((resume) => {
+    const request = evaluate()
+    const fail = (cause: unknown) => {
+      resume(Effect.fail(new Persistence.PersistenceError({ message, cause })))
+    }
+    if (request.readyState === "done") {
+      resume(Effect.succeed(request.result))
+    }
+    request.onsuccess = () => {
+      resume(Effect.succeed(request.result))
+    }
+    request.onerror = () => fail(request.error)
+  })

package/src/BrowserWorkerRunner.ts

@@ -44,7 +44,7 @@ export const make = (self: MessagePort | Window): WorkerRunner.WorkerRunnerPlatf
       Effect.scopedWith(Effect.fnUntraced(function*(scope) {
         const closeLatch = Deferred.makeUnsafe<void, WorkerError>()
         const trackFiber = Fiber.runIn(scope)
-        const services = yield* Effect.services<R>()
+        const services = yield* Effect.context<R>()
         const runFork = Effect.runForkWith(services)
         const onExit = (exit: Exit.Exit<any, E>) => {
           if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {

package/src/Clipboard.ts

@@ -1,10 +1,10 @@
 /**
  * @since 1.0.0
  */
+import * as Context from "effect/Context"
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
-import * as ServiceMap from "effect/ServiceMap"
 
 const TypeId = "~@effect/platform-browser/Clipboard"
 const ErrorTypeId = "~@effect/platform-browser/Clipboard/ClipboardError"
@@ -38,7 +38,7 @@ export class ClipboardError extends Data.TaggedError("ClipboardError")<{
  * @since 1.0.0
  * @category Service
  */
-export const Clipboard: ServiceMap.Service<Clipboard, Clipboard> = ServiceMap.Service<Clipboard>(TypeId)
+export const Clipboard: Context.Service<Clipboard, Clipboard> = Context.Service<Clipboard>(TypeId)
 
 /**
  * @since 1.0.0

package/src/Geolocation.ts

@@ -2,11 +2,11 @@
  * @since 1.0.0
  */
 import * as Cause from "effect/Cause"
+import * as Context from "effect/Context"
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Queue from "effect/Queue"
-import * as ServiceMap from "effect/ServiceMap"
 import * as Stream from "effect/Stream"
 
 const TypeId = "~@effect/platform-browser/Geolocation"
@@ -34,7 +34,7 @@ export interface Geolocation {
  * @since 1.0.0
  * @category Service
  */
-export const Geolocation: ServiceMap.Service<Geolocation, Geolocation> = ServiceMap.Service<Geolocation>(TypeId)
+export const Geolocation: Context.Service<Geolocation, Geolocation> = Context.Service<Geolocation>(TypeId)
 
 /**
  * @since 1.0.0

package/src/IndexedDb.ts

@@ -0,0 +1,97 @@
+/**
+ * @since 4.0.0
+ */
+import * as Config from "effect/Config"
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Schema from "effect/Schema"
+import * as SchemaIssue from "effect/SchemaIssue"
+
+const TypeId = "~@effect/platform-browser/IndexedDb"
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface IndexedDb {
+  readonly [TypeId]: typeof TypeId
+  readonly indexedDB: globalThis.IDBFactory
+  readonly IDBKeyRange: typeof globalThis.IDBKeyRange
+}
+
+/**
+ * @since 4.0.0
+ * @category tag
+ */
+export const IndexedDb: Context.Service<IndexedDb, IndexedDb> = Context.Service<IndexedDb, IndexedDb>(TypeId)
+
+/** @internal */
+const IDBFlatKey = Schema.Union([
+  Schema.String,
+  Schema.Number.check(Schema.makeFilter((input) => !Number.isNaN(input))),
+  Schema.DateValid,
+  Schema.declare(
+    (input): input is BufferSource =>
+      input instanceof ArrayBuffer ||
+      (ArrayBuffer.isView(input) && input.buffer instanceof ArrayBuffer)
+  )
+])
+
+/**
+ * Schema for `IDBValidKey` (`number | string | Date | BufferSource | IDBValidKey[]`).
+ *
+ * @since 4.0.0
+ * @category schemas
+ */
+export const IDBValidKey = Schema.Union([IDBFlatKey, Schema.Array(IDBFlatKey)])
+
+/**
+ * Schema for `autoIncrement` key path (`number`).
+ *
+ * @since 4.0.0
+ * @category schemas
+ */
+export const AutoIncrement = Schema.Int.check(
+  Schema.isBetween({ minimum: 1, maximum: 2 ** 53 })
+).annotate({
+  identifier: "AutoIncrement",
+  title: "autoIncrement",
+  description: "Defines a valid autoIncrement key path for the IndexedDb table"
+})
+
+/**
+ * @since 4.0.0
+ * @category constructor
+ */
+export const make = (impl: Omit<IndexedDb, typeof TypeId>): IndexedDb => IndexedDb.of({ [TypeId]: TypeId, ...impl })
+
+/**
+ * Instance of IndexedDb from the `window` object.
+ *
+ * @since 4.0.0
+ * @category constructors
+ */
+export const layerWindow: Layer.Layer<IndexedDb, Config.ConfigError> = Layer.effect(
+  IndexedDb,
+  Effect.suspend(() => {
+    if (window.indexedDB && window.IDBKeyRange) {
+      return Effect.succeed(
+        make({
+          indexedDB: window.indexedDB,
+          IDBKeyRange: window.IDBKeyRange
+        })
+      )
+    } else {
+      return Effect.fail(
+        new Config.ConfigError(
+          new Schema.SchemaError(
+            new SchemaIssue.MissingKey({
+              messageMissingKey: "window.indexedDB is not available"
+            })
+          )
+        )
+      )
+    }
+  })
+)