@effect/platform-browser 4.0.0-beta.41 → 4.0.0-beta.43

package/src/IndexedDbDatabase.ts

@@ -0,0 +1,598 @@
+/**
+ * @since 4.0.0
+ */
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import * as Fiber from "effect/Fiber"
+import * as Inspectable from "effect/Inspectable"
+import * as Layer from "effect/Layer"
+import * as Pipeable from "effect/Pipeable"
+import * as ServiceMap from "effect/ServiceMap"
+import * as Reactivity from "effect/unstable/reactivity/Reactivity"
+import * as Utils from "effect/Utils"
+import * as IndexedDb from "./IndexedDb.ts"
+import * as IndexedDbQueryBuilder from "./IndexedDbQueryBuilder.ts"
+import type * as IndexedDbTable from "./IndexedDbTable.ts"
+import type * as IndexedDbVersion from "./IndexedDbVersion.ts"
+
+const TypeId = "~@effect/platform-browser/IndexedDbDatabase"
+const ErrorTypeId = "~@effect/platform-browser/IndexedDbDatabase/IndexedDbDatabaseError"
+
+const YieldableProto = {
+  [Symbol.iterator]() {
+    return new Utils.SingleShotGen(this) as any
+  }
+}
+
+const PipeInspectableProto = {
+  ...Pipeable.Prototype,
+  ...Inspectable.BaseProto,
+  toJSON(this: any) {
+    return { _id: "IndexedDbDatabase" }
+  }
+}
+
+const CommonProto = {
+  [TypeId]: {
+    _A: (_: never) => _
+  },
+  ...PipeInspectableProto,
+  ...YieldableProto
+}
+
+/**
+ * @since 4.0.0
+ * @category errors
+ */
+export type ErrorReason =
+  | "TransactionError"
+  | "MissingTable"
+  | "OpenError"
+  | "UpgradeError"
+  | "Aborted"
+  | "Blocked"
+  | "MissingIndex"
+
+/**
+ * @since 4.0.0
+ * @category errors
+ */
+export class IndexedDbDatabaseError extends Data.TaggedError(
+  "IndexedDbDatabaseError"
+)<{
+  reason: ErrorReason
+  cause: unknown
+}> {
+  /**
+   * @since 4.0.0
+   */
+  readonly [ErrorTypeId]: typeof ErrorTypeId = ErrorTypeId
+  override readonly message = this.reason
+}
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export class IndexedDbDatabase extends ServiceMap.Service<
+  IndexedDbDatabase,
+  {
+    readonly database: globalThis.IDBDatabase
+    readonly IDBKeyRange: typeof globalThis.IDBKeyRange
+    readonly reactivity: Reactivity.Reactivity["Service"]
+  }
+>()(TypeId) {}
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface IndexedDbSchema<
+  in out FromVersion extends IndexedDbVersion.AnyWithProps,
+  in out ToVersion extends IndexedDbVersion.AnyWithProps,
+  out Error = never
+> extends
+  Pipeable.Pipeable,
+  Inspectable.Inspectable,
+  Effect.YieldableClass<
+    IndexedDbQueryBuilder.IndexedDbQueryBuilder<ToVersion>,
+    never,
+    IndexedDbDatabase
+  >
+{
+  new(_: never): {}
+
+  readonly previous: [FromVersion] extends [never] ? undefined
+    : IndexedDbSchema<never, FromVersion, Error>
+  readonly fromVersion: FromVersion
+  readonly version: ToVersion
+
+  readonly migrate: [FromVersion] extends [never] ? (query: Transaction<ToVersion>) => Effect.Effect<void, Error>
+    : (
+      fromQuery: Transaction<FromVersion>,
+      toQuery: Transaction<ToVersion>
+    ) => Effect.Effect<void, Error>
+
+  readonly add: <Version extends IndexedDbVersion.AnyWithProps, MigrationError>(
+    version: Version,
+    migrate: (
+      fromQuery: Transaction<ToVersion>,
+      toQuery: Transaction<Version>
+    ) => Effect.Effect<void, MigrationError>
+  ) => IndexedDbSchema<ToVersion, Version, MigrationError | Error>
+
+  readonly getQueryBuilder: Effect.Effect<
+    IndexedDbQueryBuilder.IndexedDbQueryBuilder<ToVersion>,
+    never,
+    IndexedDbDatabase
+  >
+
+  readonly layer: (
+    databaseName: string
+  ) => Layer.Layer<
+    IndexedDbDatabase,
+    IndexedDbDatabaseError,
+    IndexedDb.IndexedDb
+  >
+}
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface Transaction<
+  Source extends IndexedDbVersion.AnyWithProps = never
+> extends Pipeable.Pipeable, Omit<IndexedDbQueryBuilder.IndexedDbQueryBuilder<Source>, "transaction"> {
+  readonly transaction: globalThis.IDBTransaction
+
+  readonly createObjectStore: <
+    A extends IndexedDbTable.TableName<IndexedDbVersion.Tables<Source>>
+  >(
+    table: A
+  ) => Effect.Effect<globalThis.IDBObjectStore, IndexedDbDatabaseError>
+
+  readonly deleteObjectStore: <
+    A extends IndexedDbTable.TableName<IndexedDbVersion.Tables<Source>>
+  >(
+    table: A
+  ) => Effect.Effect<void, IndexedDbDatabaseError>
+
+  readonly createIndex: <
+    Name extends IndexedDbTable.TableName<IndexedDbVersion.Tables<Source>>
+  >(
+    table: Name,
+    indexName: IndexFromTableName<Source, Name>,
+    options?: IDBIndexParameters
+  ) => Effect.Effect<globalThis.IDBIndex, IndexedDbDatabaseError>
+
+  readonly deleteIndex: <
+    Name extends IndexedDbTable.TableName<IndexedDbVersion.Tables<Source>>
+  >(
+    table: Name,
+    indexName: IndexFromTableName<Source, Name>
+  ) => Effect.Effect<void, IndexedDbDatabaseError>
+}
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export type IndexFromTable<Table extends IndexedDbTable.AnyWithProps> = IsStringLiteral<
+  Extract<keyof IndexedDbTable.Indexes<Table>, string>
+> extends true ? Extract<keyof IndexedDbTable.Indexes<Table>, string>
+  : never
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export type IndexFromTableName<
+  Version extends IndexedDbVersion.AnyWithProps,
+  Table extends string
+> = IndexFromTable<
+  IndexedDbTable.WithName<IndexedDbVersion.Tables<Version>, Table>
+>
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface Any {
+  readonly previous?: Any | undefined
+  readonly layer: (
+    databaseName: string
+  ) => Layer.Layer<
+    IndexedDbDatabase,
+    IndexedDbDatabaseError,
+    IndexedDb.IndexedDb
+  >
+}
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export type AnySchema = IndexedDbSchema<
+  IndexedDbVersion.AnyWithProps,
+  IndexedDbVersion.AnyWithProps,
+  any
+>
+
+/**
+ * @since 4.0.0
+ * @category constructors
+ */
+export const make = <
+  InitialVersion extends IndexedDbVersion.AnyWithProps,
+  Error
+>(
+  initialVersion: InitialVersion,
+  init: (toQuery: Transaction<InitialVersion>) => Effect.Effect<void, Error>
+): IndexedDbSchema<never, InitialVersion, Error> =>
+  (function() {
+    // oxlint-disable-next-line typescript/no-extraneous-class
+    class Initial {}
+    Object.assign(Initial, CommonProto)
+    ;(Initial as any).version = initialVersion
+    ;(Initial as any).migrate = init
+    ;(Initial as any)._tag = "Initial"
+    ;(Initial as any).add = <Version extends IndexedDbVersion.AnyWithProps>(
+      version: Version,
+      migrate: (
+        fromQuery: Transaction<InitialVersion>,
+        toQuery: Transaction<Version>
+      ) => Effect.Effect<void, Error>
+    ) =>
+      makeProto({
+        fromVersion: initialVersion,
+        version,
+        migrate,
+        previous: Initial as any
+      })
+    ;(Initial as any).getQueryBuilder = Effect.gen(function*() {
+      const { IDBKeyRange, database, reactivity } = yield* IndexedDbDatabase
+      return IndexedDbQueryBuilder.make({
+        database,
+        IDBKeyRange,
+        tables: initialVersion.tables,
+        transaction: undefined,
+        reactivity
+      })
+    })
+    ;(Initial as any).asEffect = function() {
+      return this.getQueryBuilder
+    }
+    ;(Initial as any).layer = <DatabaseName extends string>(
+      databaseName: DatabaseName
+    ) => layer(databaseName, Initial as any)
+
+    return Initial as any
+  })()
+
+const makeProto = <
+  FromVersion extends IndexedDbVersion.AnyWithProps,
+  ToVersion extends IndexedDbVersion.AnyWithProps,
+  Error
+>(options: {
+  readonly previous:
+    | IndexedDbSchema<FromVersion, ToVersion, Error>
+    | IndexedDbSchema<never, FromVersion, Error>
+  readonly fromVersion: FromVersion
+  readonly version: ToVersion
+  readonly migrate: (
+    fromQuery: Transaction<FromVersion>,
+    toQuery: Transaction<ToVersion>
+  ) => Effect.Effect<void, Error>
+}): IndexedDbSchema<FromVersion, ToVersion, Error> =>
+  (function() {
+    // oxlint-disable-next-line typescript/no-extraneous-class
+    class Migration {}
+    Object.assign(Migration, CommonProto)
+    ;(Migration as any).previous = options.previous
+    ;(Migration as any).fromVersion = options.fromVersion
+    ;(Migration as any).version = options.version
+    ;(Migration as any).migrate = options.migrate
+    ;(Migration as any)._tag = "Migration"
+    ;(Migration as any).getQueryBuilder = Effect.gen(function*() {
+      const { IDBKeyRange, database, reactivity } = yield* IndexedDbDatabase
+      return IndexedDbQueryBuilder.make({
+        database,
+        IDBKeyRange,
+        tables: options.version.tables,
+        transaction: undefined,
+        reactivity
+      })
+    })
+    ;(Migration as any).asEffect = function() {
+      return this.getQueryBuilder
+    }
+    ;(Migration as any).layer = <DatabaseName extends string>(
+      databaseName: DatabaseName
+    ) => layer(databaseName, Migration as any)
+
+    return Migration as any
+  })()
+
+const layer = <DatabaseName extends string>(
+  databaseName: DatabaseName,
+  migration: Any
+) =>
+  Layer.effect(
+    IndexedDbDatabase,
+    Effect.gen(function*() {
+      const { IDBKeyRange, indexedDB } = yield* IndexedDb.IndexedDb
+      const reactivity = yield* Reactivity.Reactivity
+      const serviceMap = yield* Effect.services()
+      const runForkWith = Effect.runForkWith(serviceMap)
+
+      let oldVersion = 0
+      const migrations: Array<Any> = []
+      let current = migration
+      while (current) {
+        migrations.unshift(current)
+        current = (current as unknown as AnySchema).previous as any
+      }
+
+      const version = migrations.length
+      const database = yield* Effect.acquireRelease(
+        Effect.callback<globalThis.IDBDatabase, IndexedDbDatabaseError>(
+          (resume) => {
+            const request = indexedDB.open(databaseName, version)
+
+            request.onblocked = (event) => {
+              resume(
+                Effect.fail(
+                  new IndexedDbDatabaseError({
+                    reason: "Blocked",
+                    cause: event
+                  })
+                )
+              )
+            }
+
+            request.onerror = (event) => {
+              const idbRequest = event.target as IDBRequest<IDBDatabase>
+
+              resume(
+                Effect.fail(
+                  new IndexedDbDatabaseError({
+                    reason: "OpenError",
+                    cause: idbRequest.error
+                  })
+                )
+              )
+            }
+
+            let fiber: Fiber.Fiber<void, IndexedDbDatabaseError> | undefined
+            request.onupgradeneeded = (event) => {
+              const idbRequest = event.target as IDBRequest<IDBDatabase>
+              const database = idbRequest.result
+              const transaction = idbRequest.transaction
+              oldVersion = event.oldVersion
+
+              if (transaction === null) {
+                return resume(
+                  Effect.fail(
+                    new IndexedDbDatabaseError({
+                      reason: "TransactionError",
+                      cause: null
+                    })
+                  )
+                )
+              }
+
+              transaction.onabort = (event) => {
+                resume(
+                  Effect.fail(
+                    new IndexedDbDatabaseError({
+                      reason: "Aborted",
+                      cause: event
+                    })
+                  )
+                )
+              }
+
+              transaction.onerror = (event) => {
+                resume(
+                  Effect.fail(
+                    new IndexedDbDatabaseError({
+                      reason: "TransactionError",
+                      cause: event
+                    })
+                  )
+                )
+              }
+
+              const effect = Effect.forEach(
+                migrations.slice(oldVersion),
+                (untypedMigration) => {
+                  if (untypedMigration.previous === undefined) {
+                    const migration = untypedMigration as any as AnySchema
+                    const api = makeTransactionProto({
+                      database,
+                      IDBKeyRange,
+                      tables: migration.version.tables,
+                      transaction,
+                      reactivity
+                    })
+                    return (migration as any).migrate(api) as Effect.Effect<
+                      void,
+                      IndexedDbDatabaseError
+                    >
+                  } else if (untypedMigration.previous) {
+                    const migration = untypedMigration as any as AnySchema
+                    const fromApi = makeTransactionProto({
+                      database,
+                      IDBKeyRange,
+                      tables: migration.fromVersion.tables,
+                      transaction,
+                      reactivity
+                    })
+                    const toApi = makeTransactionProto({
+                      database,
+                      IDBKeyRange,
+                      tables: migration.version.tables,
+                      transaction,
+                      reactivity
+                    })
+                    return migration.migrate(fromApi, toApi) as Effect.Effect<
+                      void,
+                      IndexedDbDatabaseError
+                    >
+                  }
+
+                  return Effect.die(new Error("Invalid migration"))
+                },
+                { discard: true }
+              ).pipe(
+                Effect.mapError(
+                  (cause) =>
+                    new IndexedDbDatabaseError({
+                      reason: "UpgradeError",
+                      cause
+                    })
+                )
+              )
+              fiber = runForkWith(effect)
+              fiber.currentDispatcher.flush()
+            }
+
+            request.onsuccess = (event) => {
+              const idbRequest = event.target as IDBRequest<IDBDatabase>
+              const database = idbRequest.result
+              if (fiber) {
+                // ensure migration errors are propagated
+                resume(Effect.as(Fiber.join(fiber), database))
+              } else {
+                resume(Effect.succeed(database))
+              }
+            }
+          }
+        ),
+        (database) => Effect.sync(() => database.close())
+      )
+
+      return IndexedDbDatabase.of({ database, IDBKeyRange, reactivity })
+    })
+  ).pipe(
+    Layer.provide(Reactivity.layer)
+  )
+
+// -----------------------------------------------------------------------------
+// Internal
+// -----------------------------------------------------------------------------
+
+type IsStringLiteral<T> = T extends string ? string extends T ? false
+  : true
+  : false
+
+const makeTransactionProto = <Source extends IndexedDbVersion.AnyWithProps>({
+  IDBKeyRange,
+  database,
+  tables,
+  transaction,
+  reactivity
+}: {
+  readonly database: globalThis.IDBDatabase
+  readonly IDBKeyRange: typeof globalThis.IDBKeyRange
+  readonly tables: ReadonlyMap<string, IndexedDbVersion.Tables<Source>>
+  readonly transaction: globalThis.IDBTransaction
+  readonly reactivity: Reactivity.Reactivity["Service"]
+}): Transaction<Source> => {
+  const migration = IndexedDbQueryBuilder.make({
+    database,
+    IDBKeyRange,
+    tables,
+    transaction,
+    reactivity
+  }) as any
+
+  migration.transaction = transaction
+  migration.createObjectStore = Effect.fnUntraced(function*(table: string) {
+    const createTable = yield* Effect.fromNullishOr(tables.get(table)).pipe(
+      Effect.mapError(
+        (cause) =>
+          new IndexedDbDatabaseError({
+            reason: "MissingTable",
+            cause
+          })
+      )
+    )
+
+    return yield* Effect.try({
+      try: () =>
+        database.createObjectStore(createTable.tableName, {
+          keyPath: createTable.keyPath,
+          autoIncrement: createTable.autoIncrement
+        }),
+      catch: (cause) =>
+        new IndexedDbDatabaseError({
+          reason: "TransactionError",
+          cause
+        })
+    })
+  })
+
+  migration.deleteObjectStore = Effect.fnUntraced(function*(table: string) {
+    const createTable = yield* Effect.fromNullishOr(tables.get(table)).pipe(
+      Effect.mapError(
+        (cause) =>
+          new IndexedDbDatabaseError({
+            reason: "MissingTable",
+            cause
+          })
+      )
+    )
+
+    return yield* Effect.try({
+      try: () => database.deleteObjectStore(createTable.tableName),
+      catch: (cause) =>
+        new IndexedDbDatabaseError({
+          reason: "TransactionError",
+          cause
+        })
+    })
+  })
+
+  migration.createIndex = Effect.fnUntraced(function*(
+    table: string,
+    indexName: string,
+    options?: IDBIndexParameters
+  ) {
+    const store = transaction.objectStore(table)
+    const sourceTable = tables.get(table)!
+
+    const keyPath = yield* Effect.fromNullishOr(
+      sourceTable.indexes[indexName]
+    ).pipe(
+      Effect.mapError(
+        (cause) =>
+          new IndexedDbDatabaseError({
+            reason: "MissingIndex",
+            cause
+          })
+      )
+    )
+
+    return yield* Effect.try({
+      try: () => store.createIndex(indexName, keyPath, options),
+      catch: (cause) =>
+        new IndexedDbDatabaseError({
+          reason: "TransactionError",
+          cause
+        })
+    })
+  })
+
+  migration.deleteIndex = (table: string, indexName: string) =>
+    Effect.try({
+      try: () => transaction.objectStore(table).deleteIndex(indexName),
+      catch: (cause) =>
+        new IndexedDbDatabaseError({
+          reason: "TransactionError",
+          cause
+        })
+    })
+
+  return migration
+}