@xyo-network/schema-cache 5.3.22 → 5.3.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/schema-cache",
-  "version": "5.3.22",
+  "version": "5.3.25",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -30,43 +30,43 @@
   "types": "dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src",
     "!**/*.bench.*",
     "!**/*.spec.*",
     "!**/*.test.*",
     "README.md"
   ],
   "dependencies": {
-    "@xyo-network/domain-payload-plugin": "~5.3.22",
-    "@xyo-network/huri": "~5.3.22",
-    "@xyo-network/payload-model": "~5.3.22",
-    "@xyo-network/schema-payload-plugin": "~5.3.22"
+    "@xyo-network/payload-model": "~5.3.25",
+    "@xyo-network/schema-payload-plugin": "~5.3.25",
+    "@xyo-network/domain-payload-plugin": "~5.3.25",
+    "@xyo-network/huri": "~5.3.25"
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@types/node": "^25.5.0",
-    "@xylabs/sdk-js": "^5.0.91",
-    "@xylabs/ts-scripts-common": "~7.6.8",
-    "@xylabs/ts-scripts-yarn3": "~7.6.8",
-    "@xylabs/tsconfig": "^7.6.8",
-    "@xylabs/tsconfig-dom": "~7.6.8",
-    "@xylabs/vitest-extended": "~5.0.91",
-    "@xyo-network/network": "~5.3.22",
-    "@xyo-network/payload-builder": "~5.3.22",
+    "@xylabs/sdk-js": "^5.0.93",
+    "@xylabs/ts-scripts-common": "~7.6.16",
+    "@xylabs/ts-scripts-pnpm": "~7.6.16",
+    "@xylabs/tsconfig": "^7.6.16",
+    "@xylabs/tsconfig-dom": "~7.6.16",
+    "@xylabs/vitest-extended": "~5.0.93",
     "acorn": "^8.16.0",
     "ajv": "^8.18.0",
     "axios": "^1.14.0",
-    "cosmiconfig": "^9.0.1",
-    "esbuild": "^0.27.4",
-    "eslint": "^10.1.0",
+    "esbuild": "^0.28.0",
     "ethers": "^6.16.0",
     "lru-cache": "^11.2.7",
-    "rollup": "^4.60.1",
     "tslib": "^2.8.1",
     "typescript": "~5.9.3",
     "vite": "^8.0.3",
     "vitest": "~4.1.2",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "@xyo-network/domain-payload-plugin": "~5.3.25",
+    "@xyo-network/huri": "~5.3.25",
+    "@xyo-network/network": "~5.3.25",
+    "@xyo-network/schema-payload-plugin": "~5.3.25",
+    "@xyo-network/payload-model": "~5.3.25",
+    "@xyo-network/payload-builder": "~5.3.25"
   },
   "peerDependencies": {
     "@xylabs/sdk-js": "^5",
@@ -80,4 +80,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/Debounce.ts

@@ -1,21 +0,0 @@
-import { delay, isDefined } from '@xylabs/sdk-js'
-
-export class Debounce<TKey = string> {
-  private map = new Map<TKey, number>()
-
-  async one<T>(key: TKey, closure: () => Promise<T>, timeout = 10_000) {
-    const startTime = Date.now()
-    while (isDefined(this.map.get(key))) {
-      await delay(100)
-      if (Date.now() - startTime > timeout) {
-        throw new Error(`Debounce timed out [${key}]`)
-      }
-    }
-    try {
-      this.map.set(key, 1)
-      return await closure()
-    } finally {
-      this.map.set(key, 0)
-    }
-  }
-}

package/src/SchemaCache.ts

@@ -1,119 +0,0 @@
-import {
-  handleError, isDefined, isString,
-} from '@xylabs/sdk-js'
-import { DomainPayloadWrapper } from '@xyo-network/domain-payload-plugin'
-import type { FetchedPayload } from '@xyo-network/huri'
-import type { SchemaPayload } from '@xyo-network/schema-payload-plugin'
-import { SchemaSchema } from '@xyo-network/schema-payload-plugin'
-import type { SchemaObject } from 'ajv'
-import { Ajv } from 'ajv'
-import { isAxiosError } from 'axios'
-import { LRUCache } from 'lru-cache'
-
-import { Debounce } from './Debounce.ts'
-import type { SchemaNameToValidatorMap } from './SchemaNameToValidatorMap.ts'
-
-const getSchemaNameFromSchema = (schema: SchemaObject) => {
-  if (isString(schema.$id)) {
-    return schema.$id
-  }
-}
-
-export type SchemaCacheEntry = FetchedPayload<SchemaPayload>
-
-export class SchemaCache<T extends SchemaNameToValidatorMap = SchemaNameToValidatorMap> {
-  /**
-   * Object representing `null` since LRU Cache types
-   * only allow for types that derive from object
-   */
-  protected static readonly NULL: SchemaCacheEntry = { payload: { definition: {}, schema: SchemaSchema } }
-
-  private static _instance?: SchemaCache
-
-  onSchemaCached?: (name: string, entry: SchemaCacheEntry) => void
-  proxy?: string
-
-  private _cache = new LRUCache<string, SchemaCacheEntry>({ max: 500, ttl: 1000 * 60 * 5 })
-  private _validators: T = {} as T
-
-  // prevents double discovery
-  private getDebounce = new Debounce()
-
-  private constructor(proxy?: string) {
-    this.proxy = proxy
-  }
-
-  static get instance() {
-    if (!this._instance) {
-      this._instance = new SchemaCache()
-    }
-    return this._instance
-  }
-
-  /**
-   * A map of cached schema (by name) to payload validators for the schema. A schema
-   * must be cached via `get('schema.name')` before it's validator can be used as
-   * they are compiled dynamically at runtime upon retrieval.
-   */
-  get validators(): T {
-    return this._validators
-  }
-
-  async get(schema?: string): Promise<SchemaCacheEntry | undefined | null> {
-    if (isString(schema)) {
-      await this.getDebounce.one(schema, async () => {
-        // If we've never looked for it before, it will be undefined
-        if (this._cache.get(schema) === undefined) {
-          await this.fetchSchema(schema)
-        }
-      })
-      const value = this._cache.get(schema)
-      return value === SchemaCache.NULL ? null : value
-    }
-    return undefined
-  }
-
-  private cacheSchemaIfValid(entry: SchemaCacheEntry) {
-    // only store them if they match the schema root
-    if (isDefined(entry?.payload?.definition)) {
-      const ajv = new Ajv({ strict: false })
-      // check if it is a valid schema def
-      const validator = ajv.compile(entry.payload.definition)
-      const schemaName = getSchemaNameFromSchema(entry.payload.definition)
-      if (isString(schemaName)) {
-        this._cache.set(schemaName, entry)
-        const key = schemaName as keyof T
-        this._validators[key] = validator as unknown as T[keyof T]
-        this.onSchemaCached?.(schemaName, entry)
-      }
-    }
-  }
-
-  private cacheSchemas(aliasEntries?: FetchedPayload[] | null) {
-    for (const entry of aliasEntries?.filter(entry => entry.payload.schema === SchemaSchema) ?? []) {
-      this.cacheSchemaIfValid(entry as SchemaCacheEntry)
-    }
-  }
-
-  private async fetchSchema(schema: string) {
-    try {
-      const domain = await DomainPayloadWrapper.discover(schema, this.proxy)
-      await domain?.fetch()
-      this.cacheSchemas(domain?.aliases)
-
-      // if it is still undefined, mark it as null (not found)
-      if (this._cache.get(schema) === undefined) {
-        this._cache.set(schema, SchemaCache.NULL)
-      }
-    } catch (error) {
-      // if failed, set it to NULL, TODO: Make an entry for an error to try again in the future?
-      this._cache.set(schema, SchemaCache.NULL)
-      if (isAxiosError(error)) {
-        console.log(`Axios Url: ${error.response?.config.url}`)
-      }
-      handleError(error, (error) => {
-        console.error(`fetchSchema threw: ${error.message}`)
-      })
-    }
-  }
-}

package/src/SchemaNameToValidatorMap.ts

@@ -1,18 +0,0 @@
-import type { DomainPayload, DomainSchema } from '@xyo-network/domain-payload-plugin'
-import type { Payload, PayloadSchema } from '@xyo-network/payload-model'
-import type { SchemaPayload, SchemaSchema } from '@xyo-network/schema-payload-plugin'
-
-/**
- * Used in conjunction with schema validation to support compile time type assertion
- * for known schema types.
- */
-export type NarrowPayload<T extends Payload = Payload> = ((x: Payload) => x is T) | undefined
-
-/**
- * Used to map known schemas (byt their string name) to the validators which assert their types
- */
-export interface SchemaNameToValidatorMap {
-  [DomainSchema]: NarrowPayload<DomainPayload>
-  [PayloadSchema]: NarrowPayload<Payload>
-  [SchemaSchema]: NarrowPayload<SchemaPayload>
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from './Debounce.ts'
-export * from './SchemaCache.ts'
-export * from './SchemaNameToValidatorMap.ts'