@xyo-network/archivist-cookie 2.85.6

package/src/CookieArchivist.ts

@@ -0,0 +1,164 @@
+import { assertEx } from '@xylabs/assert'
+import { compact } from '@xylabs/lodash'
+import { fulfilled, Promisable, PromisableArray } from '@xylabs/promise'
+import { AbstractArchivist } from '@xyo-network/archivist-abstract'
+import {
+  ArchivistAllQuerySchema,
+  ArchivistClearQuerySchema,
+  ArchivistCommitQuerySchema,
+  ArchivistConfig,
+  ArchivistDeleteQuerySchema,
+  ArchivistInsertQuery,
+  ArchivistInsertQuerySchema,
+  ArchivistModuleEventData,
+  ArchivistParams,
+} from '@xyo-network/archivist-model'
+import { BoundWitness } from '@xyo-network/boundwitness-model'
+import { PayloadHasher } from '@xyo-network/hash'
+import { AnyConfigSchema } from '@xyo-network/module-model'
+import { Payload } from '@xyo-network/payload-model'
+import { PayloadWrapper } from '@xyo-network/payload-wrapper'
+import Cookies from 'js-cookie'
+
+export type CookieArchivistConfigSchema = 'network.xyo.archivist.cookie.config'
+export const CookieArchivistConfigSchema: CookieArchivistConfigSchema = 'network.xyo.archivist.cookie.config'
+
+export type CookieArchivistConfig = ArchivistConfig<{
+  domain?: string
+  maxEntries?: number
+  maxEntrySize?: number
+  namespace?: string
+  schema: CookieArchivistConfigSchema
+}>
+
+export type CookieArchivistParams = ArchivistParams<AnyConfigSchema<CookieArchivistConfig>>
+
+export class CookieArchivist<
+  TParams extends CookieArchivistParams,
+  TEventData extends ArchivistModuleEventData = ArchivistModuleEventData,
+> extends AbstractArchivist<TParams, TEventData> {
+  static override configSchemas = [CookieArchivistConfigSchema]
+
+  get domain() {
+    return this.config?.domain
+  }
+
+  get maxEntries() {
+    //all browsers support at least 60 cookies
+    return this.config?.maxEntries ?? 60
+  }
+
+  get maxEntrySize() {
+    //all browsers support at least 4000 length per cookie
+    return this.config?.maxEntrySize ?? 4000
+  }
+
+  get namespace() {
+    return this.config?.namespace ?? 'xyoarch'
+  }
+
+  override get queries(): string[] {
+    return [
+      ArchivistAllQuerySchema,
+      ArchivistDeleteQuerySchema,
+      ArchivistClearQuerySchema,
+      ArchivistInsertQuerySchema,
+      ArchivistCommitQuerySchema,
+      ...super.queries,
+    ]
+  }
+
+  protected override allHandler(): PromisableArray<Payload> {
+    try {
+      return Object.entries(Cookies.get())
+        .filter(([key]) => key.startsWith(`${this.namespace}-`))
+        .map(([, value]) => JSON.parse(value))
+    } catch (ex) {
+      console.error(`Error: ${JSON.stringify(ex, null, 2)}`)
+      throw ex
+    }
+  }
+
+  protected override clearHandler(): void | Promise<void> {
+    try {
+      Object.entries(Cookies.get()).map(([key]) => {
+        if (key.startsWith(`${this.namespace}-`)) {
+          Cookies.remove(key)
+        }
+      })
+    } catch (ex) {
+      console.error(`Error: ${JSON.stringify(ex, null, 2)}`)
+      throw ex
+    }
+  }
+
+  protected override async commitHandler(): Promise<BoundWitness[]> {
+    try {
+      const payloads = await this.all()
+      assertEx(payloads.length > 0, 'Nothing to commit')
+      const settled = await Promise.allSettled(
+        compact(
+          Object.values((await this.parents()).commit ?? [])?.map(async (parent) => {
+            const queryPayload: ArchivistInsertQuery = {
+              schema: ArchivistInsertQuerySchema,
+            }
+            const query = await this.bindQuery(queryPayload, payloads)
+            return (await parent?.query(query[0], query[1]))?.[0]
+          }),
+        ),
+      )
+      await this.clear()
+      return compact(settled.filter(fulfilled).map((result) => result.value))
+    } catch (ex) {
+      console.error(`Error: ${JSON.stringify(ex, null, 2)}`)
+      throw ex
+    }
+  }
+
+  protected override async deleteHandler(hashes: string[]): Promise<string[]> {
+    const payloadPairs: [string, Payload][] = await Promise.all(
+      (await this.get(hashes)).map<Promise<[string, Payload]>>(async (payload) => [await PayloadHasher.hashAsync(payload), payload]),
+    )
+    const deletedPairs: [string, Payload][] = compact(
+      await Promise.all(
+        payloadPairs.map<[string, Payload] | undefined>(([hash, payload]) => {
+          Cookies.remove(hash)
+          return [hash, payload]
+        }),
+      ),
+    )
+    return deletedPairs.map(([hash]) => hash)
+  }
+
+  protected override getHandler(hashes: string[]): Promisable<Payload[]> {
+    return compact(
+      hashes.map((hash) => {
+        const cookieString = Cookies.get(this.keyFromHash(hash))
+        return cookieString ? JSON.parse(cookieString) : undefined
+      }),
+    )
+  }
+
+  protected override async insertHandler(payloads: Payload[]): Promise<Payload[]> {
+    try {
+      const resultPayloads: Payload[] = await Promise.all(
+        payloads.map(async (payload) => {
+          const wrapper = PayloadWrapper.wrap(payload)
+          const key = this.keyFromHash(await wrapper.hashAsync())
+          const value = JSON.stringify(wrapper.payload())
+          assertEx(value.length < this.maxEntrySize, `Payload too large [${wrapper.hashAsync()}, ${value.length}]`)
+          Cookies.set(key, JSON.stringify(wrapper.payload()))
+          return wrapper.payload()
+        }),
+      )
+      return resultPayloads
+    } catch (ex) {
+      console.error(`Error: ${JSON.stringify(ex, null, 2)}`)
+      throw ex
+    }
+  }
+
+  private keyFromHash(hash: string) {
+    return `${this.namespace}-${hash}`
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './CookieArchivist'

package/src/spec/testArchivist.ts

@@ -0,0 +1,50 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { delay } from '@xylabs/delay'
+import { Promisable } from '@xylabs/promise'
+import { ArchivistInstance } from '@xyo-network/archivist-model'
+import { IdSchema } from '@xyo-network/id-payload-plugin'
+import { Payload } from '@xyo-network/payload-model'
+import { PayloadWrapper } from '@xyo-network/payload-wrapper'
+
+export const testArchivistRoundTrip = (archivistPromise: Promisable<ArchivistInstance>, name: string) => {
+  test(`Archivist RoundTrip [${name}]`, async () => {
+    const idPayload: Payload<{ salt: string }> = {
+      salt: Date.now().toString(),
+      schema: IdSchema,
+    }
+    const payloadWrapper = PayloadWrapper.wrap(idPayload)
+
+    const archivist = await archivistPromise
+    const insertResult = await archivist.insert([idPayload])
+    expect(insertResult).toBeDefined()
+
+    const getResult = await archivist.get([await payloadWrapper.hashAsync()])
+    expect(getResult).toBeDefined()
+    expect(getResult.length).toBe(1)
+    const gottenPayload = getResult[0]
+    if (gottenPayload) {
+      const gottenPayloadWrapper = PayloadWrapper.wrap(gottenPayload)
+      expect(await gottenPayloadWrapper.hashAsync()).toBe(await payloadWrapper.hashAsync())
+    }
+  })
+}
+
+export const testArchivistAll = (archivist: Promisable<ArchivistInstance>, name: string) => {
+  test(`Archivist All [${name}]`, async () => {
+    const idPayload = {
+      salt: Date.now().toString(),
+      schema: IdSchema,
+    }
+    const archivistModule = await archivist
+    for (let x = 0; x < 10; x++) {
+      await archivistModule.insert([idPayload])
+      await delay(10)
+    }
+    const getResult = await archivistModule.all?.()
+    expect(getResult).toBeDefined()
+    expect(getResult?.length).toBe(2)
+  })
+}

package/typedoc.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://typedoc.org/schema.json",
+  "entryPoints": ["src/index.ts"],
+  "tsconfig": "./tsconfig.typedoc.json"
+}