@xyo-network/sdk-protocol 7.0.4

package/dist/_pkg/query-payload-plugin/neutral/Payload.d.ts

@@ -0,0 +1,43 @@
+import * as z from 'zod/mini';
+export declare const QueryPayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.query" & {
+        readonly __schema: true;
+    }>;
+    query: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>;
+}, z.core.$strip>;
+export type QueryPayload = z.infer<typeof QueryPayloadZod>;
+export declare const isQueryPayload: <T>(value: T) => value is T & {
+    schema: "network.xyo.query" & {
+        readonly __schema: true;
+    };
+    query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
+};
+export declare const asQueryPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.query" & {
+            readonly __schema: true;
+        };
+        query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.query" & {
+            readonly __schema: true;
+        };
+        query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
+    };
+};
+export declare const toQueryPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.query" & {
+            readonly __schema: true;
+        };
+        query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.query" & {
+            readonly __schema: true;
+        };
+        query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
+    };
+};
+//# sourceMappingURL=Payload.d.ts.map

package/dist/_pkg/query-payload-plugin/neutral/Plugin.d.ts

@@ -0,0 +1,7 @@
+export declare const QueryPayloadPlugin: () => import("../../payload-plugin/neutral/index.ts").PayloadPlugin<{
+    schema: "network.xyo.query" & {
+        readonly __schema: true;
+    };
+    query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
+}>;
+//# sourceMappingURL=Plugin.d.ts.map

package/dist/_pkg/query-payload-plugin/neutral/Schema.d.ts

@@ -0,0 +1,5 @@
+export declare const QuerySchema: "network.xyo.query" & {
+    readonly __schema: true;
+};
+export type QuerySchema = typeof QuerySchema;
+//# sourceMappingURL=Schema.d.ts.map

package/dist/_pkg/query-payload-plugin/neutral/Template.d.ts

@@ -0,0 +1,3 @@
+import type { QueryPayload } from './Payload.ts';
+export declare const queryPayloadTemplate: () => QueryPayload;
+//# sourceMappingURL=Template.d.ts.map

package/dist/_pkg/query-payload-plugin/neutral/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Payload.ts';
+export { QueryPayloadPlugin as default, QueryPayloadPlugin } from './Plugin.ts';
+export * from './Schema.ts';
+export * from './Template.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/query-payload-plugin/neutral/index.mjs

@@ -0,0 +1,44 @@
+// src/Payload.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { PayloadZodOfSchema, SchemaZod } from "../../payload-model/neutral/index.mjs";
+import * as z from "zod/mini";
+
+// src/Schema.ts
+import { asSchema } from "../../payload-model/neutral/index.mjs";
+var QuerySchema = asSchema("network.xyo.query", true);
+
+// src/Payload.ts
+var QueryPayloadZod = z.extend(PayloadZodOfSchema(QuerySchema), { query: SchemaZod });
+var isQueryPayload = zodIsFactory(QueryPayloadZod);
+var asQueryPayload = zodAsFactory(QueryPayloadZod, "asQueryPayload");
+var toQueryPayload = zodToFactory(QueryPayloadZod, "toQueryPayload");
+
+// src/Plugin.ts
+import { createPayloadPlugin } from "../../payload-plugin/neutral/index.mjs";
+
+// src/Template.ts
+var queryPayloadTemplate = () => ({
+  query: "",
+  schema: QuerySchema
+});
+
+// src/Plugin.ts
+var QueryPayloadPlugin = () => createPayloadPlugin({
+  schema: QuerySchema,
+  template: queryPayloadTemplate
+});
+export {
+  QueryPayloadPlugin,
+  QueryPayloadZod,
+  QuerySchema,
+  asQueryPayload,
+  QueryPayloadPlugin as default,
+  isQueryPayload,
+  queryPayloadTemplate,
+  toQueryPayload
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/schema-cache/neutral/Debounce.d.ts

@@ -0,0 +1,5 @@
+export declare class Debounce<TKey = string> {
+    private map;
+    one<T>(key: TKey, closure: () => Promise<T>, timeout?: number): Promise<T>;
+}
+//# sourceMappingURL=Debounce.d.ts.map

package/dist/_pkg/schema-cache/neutral/SchemaCache.d.ts

@@ -0,0 +1,43 @@
+import type { SchemaResolution, SchemaResolutionSource } from '../../domain-payload-plugin/neutral/index.ts';
+import type { FetchedPayload } from '../../huri/neutral/index.ts';
+import type { SchemaPayload } from '../../schema-payload-plugin/neutral/index.ts';
+import type { SchemaNameToValidatorMap } from './SchemaNameToValidatorMap.ts';
+export interface SchemaCacheEntry extends FetchedPayload<SchemaPayload> {
+    /** Provenance of the schema definition when resolved via the domain schema authority */
+    source?: SchemaResolutionSource;
+}
+export declare 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;
+    private static _instance?;
+    private _cache;
+    private _resolutions;
+    private _validators;
+    private getDebounce;
+    onSchemaCached?: (name: string, entry: SchemaCacheEntry) => void;
+    proxy?: string;
+    private constructor();
+    static get instance(): SchemaCache<SchemaNameToValidatorMap>;
+    private cacheSchemaIfValid;
+    private cacheSchemas;
+    private fetchSchema;
+    /**
+     * 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;
+    get(schema?: string): Promise<SchemaCacheEntry | undefined | null>;
+    /**
+     * Resolve a schema name to its domain-published authoritative definition (SPEC.md in
+     * @xyo-network/domain-payload-plugin), with provenance and a richer status than get():
+     * 'resolved' | 'not-published' | 'unreachable'. Resolved definitions are cached and
+     * their validators compiled, exactly as with get(). 'unreachable' results are
+     * retryable: they are not cached as permanent negatives.
+     */
+    resolve(schema?: string): Promise<SchemaResolution | undefined>;
+}
+//# sourceMappingURL=SchemaCache.d.ts.map

package/dist/_pkg/schema-cache/neutral/SchemaNameToValidatorMap.d.ts

@@ -0,0 +1,12 @@
+import type { Payload } from '../../payload-model/neutral/index.ts';
+/**
+ * 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 {
+}
+//# sourceMappingURL=SchemaNameToValidatorMap.d.ts.map

package/dist/_pkg/schema-cache/neutral/TtlLruCache.d.ts

@@ -0,0 +1,13 @@
+export interface TtlLruCacheOpts {
+    max: number;
+    ttl: number;
+}
+export declare class TtlLruCache<K, V> {
+    private readonly map;
+    private readonly max;
+    private readonly ttl;
+    constructor(opts: TtlLruCacheOpts);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+}
+//# sourceMappingURL=TtlLruCache.d.ts.map

package/dist/_pkg/schema-cache/neutral/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Debounce.ts';
+export * from './SchemaCache.ts';
+export * from './SchemaNameToValidatorMap.ts';
+export * from './TtlLruCache.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/schema-cache/neutral/index.mjs

@@ -0,0 +1,178 @@
+// src/Debounce.ts
+import { delay, isDefined } from "@xylabs/sdk";
+var Debounce = class {
+  map = /* @__PURE__ */ new Map();
+  async one(key, closure, timeout = 1e4) {
+    const startTime = Date.now();
+    while (isDefined(this.map.get(key))) {
+      await delay(100);
+      if (Date.now() - startTime > timeout) {
+        throw new Error(`Debounce timed out [${String(key)}]`);
+      }
+    }
+    try {
+      this.map.set(key, 1);
+      return await closure();
+    } finally {
+      this.map.delete(key);
+    }
+  }
+};
+
+// src/SchemaCache.ts
+import {
+  FetchClientError,
+  handleError,
+  isDefined as isDefined2,
+  isString
+} from "@xylabs/sdk";
+import { DomainPayloadWrapper, DomainSchemaResolver } from "../../domain-payload-plugin/neutral/index.mjs";
+import { SchemaSchema } from "../../schema-payload-plugin/neutral/index.mjs";
+import { Ajv } from "ajv";
+
+// src/TtlLruCache.ts
+var TtlLruCache = class {
+  map = /* @__PURE__ */ new Map();
+  max;
+  ttl;
+  constructor(opts) {
+    this.max = opts.max;
+    this.ttl = opts.ttl;
+  }
+  get(key) {
+    const entry = this.map.get(key);
+    if (entry === void 0) return void 0;
+    if (entry.expires <= Date.now()) {
+      this.map.delete(key);
+      return void 0;
+    }
+    this.map.delete(key);
+    this.map.set(key, entry);
+    return entry.value;
+  }
+  set(key, value) {
+    if (this.map.has(key)) this.map.delete(key);
+    this.map.set(key, { value, expires: Date.now() + this.ttl });
+    if (this.map.size > this.max) {
+      const oldest = this.map.keys().next().value;
+      if (oldest !== void 0) this.map.delete(oldest);
+    }
+  }
+};
+
+// src/SchemaCache.ts
+var getSchemaNameFromSchema = (schema) => {
+  if (isString(schema.$id)) {
+    return schema.$id;
+  }
+};
+var SchemaCache = class _SchemaCache {
+  /**
+   * Object representing `null` since LRU Cache types
+   * only allow for types that derive from object
+   */
+  static NULL = { payload: { definition: {}, schema: SchemaSchema } };
+  static _instance;
+  _cache = new TtlLruCache({ max: 500, ttl: 1e3 * 60 * 5 });
+  _resolutions = new TtlLruCache({ max: 500, ttl: 1e3 * 60 * 5 });
+  _validators = {};
+  // prevents double discovery
+  getDebounce = new Debounce();
+  onSchemaCached;
+  proxy;
+  constructor(proxy) {
+    this.proxy = proxy;
+  }
+  static get instance() {
+    this._instance ??= new _SchemaCache();
+    return this._instance;
+  }
+  cacheSchemaIfValid(entry) {
+    if (!isDefined2(entry?.payload?.definition)) {
+      return;
+    }
+    const ajv = new Ajv({ strict: false });
+    const validator = ajv.compile(entry.payload.definition);
+    const schemaName = getSchemaNameFromSchema(entry.payload.definition);
+    if (isString(schemaName)) {
+      this._cache.set(schemaName, entry);
+      const key = schemaName;
+      this._validators[key] = validator;
+      this.onSchemaCached?.(schemaName, entry);
+    }
+  }
+  cacheSchemas(aliasEntries) {
+    for (const entry of aliasEntries?.filter((entry2) => entry2.payload.schema === SchemaSchema) ?? []) {
+      this.cacheSchemaIfValid(entry);
+    }
+  }
+  async fetchSchema(schema) {
+    try {
+      const resolution = await this.resolve(schema);
+      if (resolution?.status === "resolved") {
+        return;
+      }
+      const domain = await DomainPayloadWrapper.discover(schema, this.proxy);
+      await domain?.fetch();
+      this.cacheSchemas(domain?.aliases);
+      if (this._cache.get(schema) === void 0 && resolution?.status !== "unreachable") {
+        this._cache.set(schema, _SchemaCache.NULL);
+      }
+    } catch (error) {
+      if (error instanceof FetchClientError) {
+        console.log(`Fetch Url: ${error.config.url}`);
+      }
+      handleError(error, (error2) => {
+        console.error(`fetchSchema threw: ${error2.message}`);
+      });
+    }
+  }
+  /**
+   * 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() {
+    return this._validators;
+  }
+  async get(schema) {
+    if (isString(schema)) {
+      await this.getDebounce.one(schema, async () => {
+        if (this._cache.get(schema) === void 0) {
+          await this.fetchSchema(schema);
+        }
+      });
+      const value = this._cache.get(schema);
+      return value === _SchemaCache.NULL ? null : value;
+    }
+    return void 0;
+  }
+  /**
+   * Resolve a schema name to its domain-published authoritative definition (SPEC.md in
+   * @xyo-network/domain-payload-plugin), with provenance and a richer status than get():
+   * 'resolved' | 'not-published' | 'unreachable'. Resolved definitions are cached and
+   * their validators compiled, exactly as with get(). 'unreachable' results are
+   * retryable: they are not cached as permanent negatives.
+   */
+  async resolve(schema) {
+    if (!isString(schema)) return void 0;
+    await this.getDebounce.one(`resolve:${schema}`, async () => {
+      const existing = this._resolutions.get(schema);
+      if (existing === void 0 || existing.status === "unreachable") {
+        const resolver = new DomainSchemaResolver();
+        const resolution = await resolver.resolve(schema, { proxy: this.proxy });
+        this._resolutions.set(schema, resolution);
+        if (resolution.status === "resolved" && isDefined2(resolution.payload)) {
+          this.cacheSchemaIfValid({ payload: resolution.payload, source: resolution.source });
+        }
+      }
+    });
+    return this._resolutions.get(schema);
+  }
+};
+export {
+  Debounce,
+  SchemaCache,
+  TtlLruCache
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/schema-name-validator/neutral/SchemaNameValidator.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Validates a XYO schema name's structure
+ */
+export declare class SchemaNameValidator {
+    private _parts?;
+    private _rootDomain?;
+    private _schema?;
+    constructor(schema?: string);
+    /**
+     * Checks whether the schema is all lowercase
+     *
+     * @returns boolean
+     */
+    get isLowercase(): boolean;
+    /**
+     * Levels in the schema
+     *
+     * @returns number
+     */
+    get levels(): number | undefined;
+    /**
+     * The schema converted into a string array split on '.'
+     *
+     * @returns string[]
+     */
+    get parts(): string[] | undefined;
+    /**
+     * The rootDomain is the first two levels of the schema, in reverse order
+     * This can be used to determine who 'owns' that schema, based on domain
+     * registration
+     *
+     * @returns string
+     */
+    get rootDomain(): string | undefined;
+    get schema(): string | undefined;
+    set schema(schema: string | undefined);
+    /**
+     * Run all static validations
+     * @returns Error[]
+     */
+    all(): Error[];
+}
+//# sourceMappingURL=SchemaNameValidator.d.ts.map

package/dist/_pkg/schema-name-validator/neutral/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SchemaNameValidator.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/schema-name-validator/neutral/index.mjs

@@ -0,0 +1,69 @@
+// src/SchemaNameValidator.ts
+var SchemaNameValidator = class {
+  _parts;
+  _rootDomain;
+  _schema;
+  constructor(schema) {
+    this._schema = schema;
+  }
+  /**
+   * Checks whether the schema is all lowercase
+   *
+   * @returns boolean
+   */
+  get isLowercase() {
+    return this.schema === this.schema?.toLowerCase();
+  }
+  /**
+   * Levels in the schema
+   *
+   * @returns number
+   */
+  get levels() {
+    return this.parts?.length;
+  }
+  /**
+   * The schema converted into a string array split on '.'
+   *
+   * @returns string[]
+   */
+  get parts() {
+    this._parts = this._parts ?? this.schema?.split(".");
+    return this._parts;
+  }
+  /**
+   * The rootDomain is the first two levels of the schema, in reverse order
+   * This can be used to determine who 'owns' that schema, based on domain
+   * registration
+   *
+   * @returns string
+   */
+  get rootDomain() {
+    this._rootDomain = this._rootDomain ?? domainLevel(this, 1);
+    return this._rootDomain;
+  }
+  get schema() {
+    return this._schema;
+  }
+  set schema(schema) {
+    this._schema = schema;
+  }
+  /**
+   * Run all static validations
+   * @returns Error[]
+   */
+  all() {
+    const errors = [];
+    if ((this.schema?.length ?? 0) === 0) errors.push(new Error("schema missing"));
+    else if ((this.levels ?? 0) < 3) errors.push(new Error(`schema levels < 3 [${this.levels}, ${this.schema}]`));
+    else if (!this.isLowercase) errors.push(new Error(`schema not lowercase [${this.schema}]`));
+    return errors;
+  }
+};
+function domainLevel(validator, level) {
+  return validator.parts?.slice(0, level + 1).toReversed().join(".");
+}
+export {
+  SchemaNameValidator
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/schema-payload-plugin/neutral/Payload.d.ts

@@ -0,0 +1,96 @@
+import * as z from 'zod/mini';
+export declare const SchemaPayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.schema" & {
+        readonly __schema: true;
+    }>;
+    definition: z.ZodMiniObject<{
+        $id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$loose>;
+    extends: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    version: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+}, z.core.$strip>;
+export type SchemaPayload = z.infer<typeof SchemaPayloadZod>;
+/**
+ * Identity function for determining if an object is a Schema
+ */
+export declare const isSchemaPayload: <T>(value: T) => value is T & {
+    schema: "network.xyo.schema" & {
+        readonly __schema: true;
+    };
+    definition: {
+        [x: string]: unknown;
+        $id?: string | undefined;
+    };
+    extends?: string | undefined;
+    name?: string | undefined;
+    version?: number | undefined;
+};
+export declare const asSchemaPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.schema" & {
+            readonly __schema: true;
+        };
+        definition: {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        };
+        extends?: string | undefined;
+        name?: string | undefined;
+        version?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.schema" & {
+            readonly __schema: true;
+        };
+        definition: {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        };
+        extends?: string | undefined;
+        name?: string | undefined;
+        version?: number | undefined;
+    };
+};
+export declare const toSchemaPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.schema" & {
+            readonly __schema: true;
+        };
+        definition: {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        };
+        extends?: string | undefined;
+        name?: string | undefined;
+        version?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.schema" & {
+            readonly __schema: true;
+        };
+        definition: {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        };
+        extends?: string | undefined;
+        name?: string | undefined;
+        version?: number | undefined;
+    };
+};
+/**
+ * Identity function for determining if an object is a Schema with sources
+ */
+export declare const isSchemaPayloadWithSources: (x?: unknown) => x is import("../../payload-model/neutral/index.ts").WithSources<{
+    schema: "network.xyo.schema" & {
+        readonly __schema: true;
+    };
+    definition: {
+        [x: string]: unknown;
+        $id?: string | undefined;
+    };
+    extends?: string | undefined;
+    name?: string | undefined;
+    version?: number | undefined;
+}>;
+//# sourceMappingURL=Payload.d.ts.map

package/dist/_pkg/schema-payload-plugin/neutral/Plugin.d.ts

@@ -0,0 +1,13 @@
+export declare const SchemaPayloadPlugin: () => import("../../payload-plugin/neutral/index.ts").PayloadPlugin<{
+    schema: "network.xyo.schema" & {
+        readonly __schema: true;
+    };
+    definition: {
+        [x: string]: unknown;
+        $id?: string | undefined;
+    };
+    extends?: string | undefined;
+    name?: string | undefined;
+    version?: number | undefined;
+}>;
+//# sourceMappingURL=Plugin.d.ts.map

package/dist/_pkg/schema-payload-plugin/neutral/Schema.d.ts

@@ -0,0 +1,5 @@
+export declare const SchemaSchema: "network.xyo.schema" & {
+    readonly __schema: true;
+};
+export type SchemaSchema = typeof SchemaSchema;
+//# sourceMappingURL=Schema.d.ts.map

package/dist/_pkg/schema-payload-plugin/neutral/Template.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaPayload } from './Payload.ts';
+export declare const schemaPayloadTemplate: () => SchemaPayload;
+//# sourceMappingURL=Template.d.ts.map

package/dist/_pkg/schema-payload-plugin/neutral/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Payload.ts';
+export { SchemaPayloadPlugin as default, SchemaPayloadPlugin } from './Plugin.ts';
+export * from './Schema.ts';
+export * from './Template.ts';
+//# sourceMappingURL=index.d.ts.map