@atproto-labs/simple-store 0.4.1 → 0.4.3

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @atproto-labs/simple-store
 
+## 0.4.3
+
+### Patch Changes
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Update TypeScript build to rely on references to composite internal projects
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Bundle only necessary files in the NPM tarball, including the `CHANGELOG.md` and `README.md` files (if present).
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Build with `noImplicitAny` enabled
+
+## 0.4.2
+
+### Patch Changes
+
+- [#5151](https://github.com/bluesky-social/atproto/pull/5151) [`a51c45d`](https://github.com/bluesky-social/atproto/commit/a51c45d38f6bd7b8765f640e564cf921d52162e7) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Update dependencies
+
 ## 0.4.1
 
 ### Patch Changes

package/package.json

@@ -1,9 +1,6 @@
 {
   "name": "@atproto-labs/simple-store",
-  "version": "0.4.1",
-  "engines": {
-    "node": ">=22"
-  },
+  "version": "0.4.3",
   "license": "MIT",
   "description": "Simple store interfaces & utilities",
   "keywords": [
@@ -16,6 +13,10 @@
     "url": "https://github.com/bluesky-social/atproto",
     "directory": "packages/internal/simple-store"
   },
+  "files": [
+    "./dist",
+    "./CHANGELOG.md"
+  ],
   "type": "module",
   "exports": {
     ".": {
@@ -23,7 +24,9 @@
       "default": "./dist/index.js"
     }
   },
-  "devDependencies": {},
+  "engines": {
+    "node": ">=22"
+  },
   "scripts": {
     "build": "tsgo --build tsconfig.build.json"
   }

package/src/cached-getter.ts

@@ -1,201 +0,0 @@
-import { GetOptions, Key, SimpleStore, Value } from './simple-store.js'
-import { Awaitable, ContextOptions } from './util.js'
-
-export type { GetOptions }
-export type GetCachedOptions<C = void> = ContextOptions<C> & {
-  signal?: AbortSignal
-
-  /**
-   * Do not use the cache to get the value. Always get a new value from the
-   * getter function.
-   *
-   * @default false
-   */
-  noCache?: boolean
-
-  /**
-   * When getting a value from the cache, allow the value to be returned even if
-   * it is stale.
-   *
-   * Has no effect if the `isStale` option was not provided to the CachedGetter.
-   *
-   * @default true // If the CachedGetter has an isStale option
-   * @default false // If no isStale option was provided to the CachedGetter
-   */
-  allowStale?: boolean
-}
-
-export type GetterOptions<C = void> = {
-  context: C extends void ? undefined : C
-  noCache: boolean
-  signal?: AbortSignal
-}
-
-export type Getter<K extends Key, V extends Value, C = void> = (
-  key: K,
-  options: GetterOptions<C>,
-  storedValue: undefined | V,
-) => Awaitable<V>
-
-export type CachedGetterOptions<K extends Key, V extends Value> = {
-  isStale?: (key: K, value: V) => boolean | PromiseLike<boolean>
-  onStoreError?: (err: unknown, key: K, value: V) => void | PromiseLike<void>
-  deleteOnError?: (
-    err: unknown,
-    key: K,
-    value: V,
-  ) => boolean | PromiseLike<boolean>
-}
-
-type PendingItem<V> = Promise<{ value: V; isFresh: boolean }>
-
-const returnTrue = () => true
-const returnFalse = () => false
-
-/**
- * Wrapper utility that uses a store to speed up the retrieval of values from an
- * (expensive) getter function.
- */
-export class CachedGetter<
-  K extends Key = string,
-  V extends Value = Value,
-  C = void,
-> {
-  private readonly pending = new Map<K, PendingItem<V>>()
-
-  constructor(
-    readonly getter: Getter<K, V, C>,
-    readonly store: SimpleStore<K, V>,
-    readonly options: CachedGetterOptions<K, V> = {},
-  ) {}
-
-  async get(
-    key: C extends void ? K : never,
-    options?: GetCachedOptions<C>,
-  ): Promise<V>
-  async get(
-    key: C extends void ? never : K,
-    options: GetCachedOptions<C>,
-  ): Promise<V>
-  async get(
-    key: K,
-    {
-      signal,
-      context,
-      allowStale = false,
-      noCache = false,
-    } = {} as GetCachedOptions<C>,
-  ): Promise<V> {
-    signal?.throwIfAborted()
-
-    const { isStale, deleteOnError } = this.options
-
-    const allowStored: (value: V) => Awaitable<boolean> = noCache
-      ? returnFalse // Never allow stored values to be returned
-      : allowStale || isStale == null
-        ? returnTrue // Always allow stored values to be returned
-        : async (value: V) => !(await isStale(key, value))
-
-    // As long as concurrent requests are made for the same key, only one
-    // request will be made to the getStored & getter functions at a time. This
-    // works because there is no async operation between the while() loop and
-    // the pending.set() call below. Because of the single threaded nature of
-    // JavaScript, the pending item will be set before the next iteration of the
-    // while loop of any concurrent request.
-    let previousExecutionFlow: undefined | PendingItem<V>
-    while ((previousExecutionFlow = this.pending.get(key))) {
-      try {
-        // If a concurrent request is already in progress, wait for it to finish
-        const { isFresh, value } = await previousExecutionFlow
-
-        // Use the concurrent request's result if it is fresh
-        if (isFresh) return value
-        // Use the concurrent request's result if not fresh (loaded from the
-        // store), and matches the conditions for using a stored value.
-        if (await allowStored(value)) return value
-      } catch {
-        // Ignore errors from previous execution flows (they will have been
-        // propagated by that flow).
-      }
-
-      // Break the loop if the signal was aborted
-      signal?.throwIfAborted()
-    }
-
-    const currentExecutionFlow: PendingItem<V> = Promise.resolve()
-      .then(async () => {
-        const storedValue = await this.getStored(key, { signal })
-
-        if (storedValue !== undefined && (await allowStored(storedValue))) {
-          // Use the stored value as return value for the current execution
-          // flow. Notify other concurrent execution flows (that should be
-          // "stuck" in the loop before until this promise resolves) that we got
-          // a value, but that it came from the store (isFresh = false).
-          return { isFresh: false, value: storedValue }
-        }
-
-        return Promise.resolve()
-          .then(async () => {
-            const options = { signal, noCache, context } as GetterOptions<C>
-            return this.getter.call(null, key, options, storedValue)
-          })
-          .catch(async (err) => {
-            if (storedValue !== undefined) {
-              try {
-                if (await deleteOnError?.(err, key, storedValue)) {
-                  await this.delStored(key, err)
-                }
-              } catch (error) {
-                throw new AggregateError(
-                  [err, error],
-                  'Error while deleting stored value',
-                )
-              }
-            }
-            throw err
-          })
-          .then(async (value) => {
-            // The value should be stored even is the signal was aborted.
-            await this.setStored(key, value)
-            return { isFresh: true, value }
-          })
-      })
-      .finally(() => {
-        this.pending.delete(key)
-      })
-
-    if (this.pending.has(key)) {
-      // This should never happen. Indeed, there must not be any 'await'
-      // statement between this and the loop iteration check meaning that
-      // this.pending.get returned undefined. It is there to catch bugs that
-      // would occur in future changes to the code.
-      throw new Error('Concurrent request for the same key')
-    }
-
-    this.pending.set(key, currentExecutionFlow)
-
-    const { value } = await currentExecutionFlow
-    return value
-  }
-
-  async getStored(key: K, options?: GetOptions): Promise<V | undefined> {
-    try {
-      return await this.store.get(key, options)
-    } catch (err) {
-      return undefined
-    }
-  }
-
-  async setStored(key: K, value: V): Promise<void> {
-    try {
-      await this.store.set(key, value)
-    } catch (err) {
-      const onStoreError = this.options?.onStoreError
-      await onStoreError?.(err, key, value)
-    }
-  }
-
-  async delStored(key: K, _cause?: unknown): Promise<void> {
-    await this.store.del(key)
-  }
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from './cached-getter.js'
-export * from './simple-store.js'
-export * from './util.js'

package/src/simple-store.ts

@@ -1,16 +0,0 @@
-import { Awaitable } from './util.js'
-
-export type Key = NonNullable<unknown>
-export type Value = NonNullable<unknown> | null
-
-export type GetOptions = { signal?: AbortSignal }
-
-export interface SimpleStore<K extends Key, V extends Value> {
-  /**
-   * @return undefined if the key is not in the store (which is why Value cannot contain "undefined").
-   */
-  get: (key: K, options?: GetOptions) => Awaitable<undefined | V>
-  set: (key: K, value: V) => Awaitable<void>
-  del: (key: K) => Awaitable<void>
-  clear?: () => Awaitable<void>
-}

package/src/util.ts

@@ -1,5 +0,0 @@
-export type Awaitable<V> = V | PromiseLike<V>
-
-export type ContextOptions<C> = C extends void | undefined
-  ? { context?: undefined }
-  : { context: C }

package/tsconfig.build.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../../tsconfig/isomorphic.json",
-  "compilerOptions": {
-    "rootDir": "./src",
-    "outDir": "./dist",
-  },
-  "include": ["./src"],
-}

package/tsconfig.build.tsbuildinfo

@@ -1 +0,0 @@
-{"version":"7.0.0-dev.20260614.1","root":["./src/cached-getter.ts","./src/index.ts","./src/simple-store.ts","./src/util.ts"]}

package/tsconfig.json

@@ -1,4 +0,0 @@
-{
-  "include": [],
-  "references": [{ "path": "./tsconfig.build.json" }],
-}