@xyo-network/module-model 5.3.20 → 5.3.24

package/src/ModuleFactoryLocatorInstance.ts

@@ -1,47 +0,0 @@
-import type { Schema } from '@xyo-network/payload-model'
-
-import type {
-  CreatableModuleFactory, CreatableModuleRegistry, LabeledCreatableModuleFactory,
-} from './CreatableModule/index.ts'
-import type { Labels } from './Labels/index.ts'
-
-export interface ModuleFactoryLocatorInstance {
-
-  /**
-   * The current registry for the module factory
-   */
-  registry: Readonly<CreatableModuleRegistry>
-
-  freeze(): void
-
-  /**
-   * Locates a module factory that matches the supplied schema and labels
-   * @param schema The config schema for the module
-   * @param labels The labels for the module factory
-   * @returns A module factory that matches the supplied schema and labels or throws if one is not found
-   */
-  locate(schema: string, labels?: Labels): CreatableModuleFactory | LabeledCreatableModuleFactory
-
-  merge(locator: ModuleFactoryLocatorInstance): ModuleFactoryLocatorInstance
-
-  /**
-   * Registers a single module factory (with optional tags) with the locator
-   * @param factory The factory to register
-   * @param labels The labels for the module factory
-   */
-  register(factory: CreatableModuleFactory, labels?: Labels, primary?: boolean | Schema | Schema[]): ModuleFactoryLocatorInstance
-
-  /**
-   * Registers multiple module factories with the locator
-   * @param factories The factories to register
-   */
-  registerMany(factories: CreatableModuleFactory[]): ModuleFactoryLocatorInstance
-
-  /**
-   * Tries to locate a module factory that matches the supplied schema and labels
-   * @param schema The config schema for the module
-   * @param labels The labels for the module factory
-   * @returns A module factory that matches the supplied schema and labels or undefined
-   */
-  tryLocate(schema: string, labels?: Labels): CreatableModuleFactory | LabeledCreatableModuleFactory | undefined
-}

package/src/ModuleIdentifier.ts

@@ -1,69 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { isAddress } from '@xylabs/sdk-js'
-
-export const MODULE_PATH_SEPARATOR = ':' as const
-
-export const DisallowedModuleIdentifierCharacters = {
-  ' ': true,
-  '!': true,
-  '"': true,
-  '#': true,
-  '$': true,
-  '%': true,
-  '&': true,
-  "'": true,
-  '(': true,
-  ')': true,
-  '*': true,
-  ',': true,
-  '.': true,
-  '/': true,
-  ':': true,
-  ';': true,
-  '<': true,
-  '=': true,
-  '>': true,
-  '?': true,
-  '@': true,
-  '[': true,
-  ']': true,
-  '^': true,
-  '_': true,
-  '{': true,
-  '|': true,
-  '}': true,
-  '~': true,
-}
-export type ReservedModuleIdentifierCharacter = keyof typeof DisallowedModuleIdentifierCharacters
-export const ReservedModuleIdentifierCharacters = new Set<ReservedModuleIdentifierCharacter>(
-  Object.keys(DisallowedModuleIdentifierCharacters) as ReservedModuleIdentifierCharacter[],
-)
-
-// TODO: Use Brand, but avoid too complex error
-// export type ModuleName = Brand<string, { __moduleName: true }>
-export type ModuleName = string
-
-export type ModuleIdentifier
-  = | ColonPair<ModuleIdentifierPart>
-    | ColonPair<ColonPair<ModuleIdentifierPart>>
-    | ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>
-    | ColonPair<ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>>
-    | ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>>>
-    | ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>>>>
-    | ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>>>>>
-
-export type ColonPair<T extends string> = `${T}:${T}` | T
-
-export type ModuleIdentifierPart = Exclude<Address | ModuleName, '*'>
-
-export const isModuleName = (value: unknown): value is ModuleName => {
-  return typeof value === 'string' && !isAddress(value) && !includesReservedModuleIdentifierCharacter(value)
-}
-
-export const includesReservedModuleIdentifierCharacter = (value: unknown): boolean => {
-  return typeof value === 'string' && [...value].some(char => ReservedModuleIdentifierCharacters.has(char as ReservedModuleIdentifierCharacter))
-}
-
-export const isModuleIdentifierPart = (value: unknown): value is ModuleIdentifierPart => {
-  return isModuleName(value) || isAddress(value)
-}

package/src/ModuleIdentifierTransformer.ts

@@ -1,9 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-
-import type { ModuleIdentifier } from './ModuleIdentifier.ts'
-
-export type ModuleIdentifierTransformerFunc = (id: ModuleIdentifier) => Promisable<ModuleIdentifier | undefined>
-
-export interface ModuleIdentifierTransformer {
-  transform: ModuleIdentifierTransformerFunc
-}

package/src/ModuleQueryHandlerResult.ts

@@ -1,3 +0,0 @@
-import type { Payload } from '@xyo-network/payload-model'
-
-export type ModuleQueryHandlerResult = Payload[]

package/src/ModuleQueryResult.ts

@@ -1,8 +0,0 @@
-import type { BoundWitness } from '@xyo-network/boundwitness-model'
-import type { ModuleError, Payload } from '@xyo-network/payload-model'
-
-export type ModuleQueryResult<P extends Payload = Payload, E extends ModuleError = ModuleError, B extends BoundWitness = BoundWitness> = [
-  B,
-  P[],
-  E[],
-]

package/src/ModuleStatusReporter.ts

@@ -1,3 +0,0 @@
-import type { CreatableStatusReporter } from '@xylabs/sdk-js'
-
-export interface ModuleStatusReporter extends CreatableStatusReporter {}

package/src/Payload/Address.ts

@@ -1,37 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { AsObjectFactory } from '@xylabs/sdk-js'
-import {
-  asSchema, isPayloadOfSchemaType, type Payload,
-} from '@xyo-network/payload-model'
-
-export const AddressSchema = asSchema('network.xyo.address', true)
-export type AddressSchema = typeof AddressSchema
-
-export const AddressChildSchema = asSchema('network.xyo.address.child', true)
-export type AddressChildSchema = typeof AddressChildSchema
-
-export interface AddressFields {
-  address: Address
-}
-
-export type AddressPayload = Payload<AddressFields, AddressSchema>
-
-/**
- * Identity function for determining if an object is an Address
- */
-export const isAddressPayload = isPayloadOfSchemaType<AddressPayload>(AddressSchema)
-export const asAddressPayload = AsObjectFactory.create(isAddressPayload)
-export const asOptionalAddressPayload = AsObjectFactory.createOptional(isAddressPayload)
-
-export interface AddressChildFields extends AddressFields {
-  /**
-   * The derivation path of the child address
-   */
-  path?: string
-  /**
-   * The public address of the root of the hierarchy
-   */
-  root?: Address
-}
-
-export type AddressChildPayload = Payload<AddressChildFields, AddressChildSchema>

package/src/Payload/AddressPreviousHash.ts

@@ -1,13 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { asSchema, type Payload } from '@xyo-network/payload-model'
-
-export const AddressPreviousHashSchema = asSchema('network.xyo.address.hash.previous', true)
-export type AddressPreviousHashSchema = typeof AddressPreviousHashSchema
-
-export type AddressPreviousHashPayload = Payload<
-  {
-    address: Address
-    previousHash?: string
-  },
-  AddressPreviousHashSchema
->

package/src/Payload/Description.ts

@@ -1,8 +0,0 @@
-import { asSchema, type Payload } from '@xyo-network/payload-model'
-
-import type { ModuleDescription } from '../ModuleDescription.ts'
-
-export const ModuleDescriptionSchema = asSchema('network.xyo.module.description', true)
-export type ModuleDescriptionSchema = typeof ModuleDescriptionSchema
-
-export type ModuleDescriptionPayload = Payload<ModuleDescription, ModuleDescriptionSchema>

package/src/Payload/ModuleState.ts

@@ -1,29 +0,0 @@
-import { AsObjectFactory } from '@xylabs/sdk-js'
-import type { Payload, WithSources } from '@xyo-network/payload-model'
-import {
-  asSchema, isPayloadOfSchemaType, isPayloadOfSchemaTypeWithSources,
-} from '@xyo-network/payload-model'
-
-export interface StateDictionary {
-  [key: string]: string | number
-}
-export interface State<T extends StateDictionary = StateDictionary> {
-  state: T
-}
-
-export const ModuleStateSchema = asSchema('network.xyo.module.state', true)
-export type ModuleStateSchema = typeof ModuleStateSchema
-
-export type ModuleState<T extends StateDictionary = StateDictionary> = Payload<State<T>, ModuleStateSchema>
-
-export const isModuleState = <T extends StateDictionary = StateDictionary, TInput = unknown>(payload?: TInput): payload is ModuleState<T> & TInput => {
-  return isPayloadOfSchemaType<ModuleState<T>>(ModuleStateSchema)(payload)
-}
-
-export const isModuleStateWithSources = <T extends StateDictionary = StateDictionary,
-  TInput = unknown>(payload?: TInput): payload is WithSources<ModuleState<T>> & TInput => {
-  return isPayloadOfSchemaTypeWithSources<ModuleState<T>>(ModuleStateSchema)(payload)
-}
-
-export const asModuleState = AsObjectFactory.create<ModuleState<StateDictionary>>(isModuleState)
-export const asOptionalModuleState = AsObjectFactory.createOptional<ModuleState<StateDictionary>>(isModuleState)

package/src/Payload/index.ts

@@ -1,4 +0,0 @@
-export * from './Address.ts'
-export * from './AddressPreviousHash.ts'
-export * from './Description.ts'
-export * from './ModuleState.ts'

package/src/Queries/Manifest.ts

@@ -1,9 +0,0 @@
-import { asSchema, type Query } from '@xyo-network/payload-model'
-
-export const ModuleManifestQuerySchema = asSchema('network.xyo.query.module.manifest', true)
-export type ModuleManifestQuerySchema = typeof ModuleManifestQuerySchema
-
-export type ModuleManifestQuery = Query<{
-  maxDepth?: number
-  schema: ModuleManifestQuerySchema
-}>

package/src/Queries/ModuleAddress/Query.ts

@@ -1,8 +0,0 @@
-import { asSchema, type Query } from '@xyo-network/payload-model'
-
-export const ModuleAddressQuerySchema = asSchema('network.xyo.query.module.address', true)
-export type ModuleAddressQuerySchema = typeof ModuleAddressQuerySchema
-
-export type ModuleAddressQuery = Query<{
-  schema: ModuleAddressQuerySchema
-}>

package/src/Queries/ModuleAddress/index.ts

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

package/src/Queries/State.ts

@@ -1,6 +0,0 @@
-import { asSchema, type Query } from '@xyo-network/payload-model'
-
-export const ModuleStateQuerySchema = asSchema('network.xyo.query.module.state', true)
-export type ModuleStateQuerySchema = typeof ModuleStateQuerySchema
-
-export type ModuleStateQuery = Query<void, ModuleStateQuerySchema>

package/src/Queries/Subscribe.ts

@@ -1,21 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { asSchema, type Query } from '@xyo-network/payload-model'
-
-export const ModuleSubscribeQuerySchema = asSchema('network.xyo.query.module.subscribe', true)
-export type ModuleSubscribeQuerySchema = typeof ModuleSubscribeQuerySchema
-
-export interface ModuleSubscribeFilter {
-  /** @field if specified, at least one of the schemas must be present in the boundwtness to generate a notification */
-  schema?: string[]
-}
-
-// requests notification when a boundwitness is added to the modules chain that meets the filter criteria
-export type ModuleSubscribeQuery = Query<{
-  /** @field The address that will receive notifications */
-  address: Address
-  /** @field A subscribe with a null for filter is an unsubscribe */
-  filter?: ModuleSubscribeFilter | null
-  /** @field The maximum events queued per send [may increase frequency] */
-  maxQueue?: number
-  schema: ModuleSubscribeQuerySchema
-}>

package/src/Queries/index.ts

@@ -1,11 +0,0 @@
-import type { ModuleManifestQuery } from './Manifest.ts'
-import type { ModuleAddressQuery } from './ModuleAddress/index.ts'
-import type { ModuleStateQuery } from './State.ts'
-import type { ModuleSubscribeQuery } from './Subscribe.ts'
-
-export * from './Manifest.ts'
-export * from './ModuleAddress/index.ts'
-export * from './State.ts'
-export * from './Subscribe.ts'
-
-export type ModuleQueries = ModuleAddressQuery | ModuleSubscribeQuery | ModuleManifestQuery | ModuleStateQuery

package/src/QueryableModule/IsQueryableModuleFactory.ts

@@ -1,34 +0,0 @@
-import type {
-  AnyNonPromise,
-  AnyObject, EmptyObject, TypeCheck,
-  TypeCheckConfig,
-} from '@xylabs/sdk-js'
-
-import { asQueryableModuleObject } from './asQueryableModuleObject.ts'
-import { isQueryableModuleObject } from './isQueryableModuleObject.ts'
-import type { QueryableModule } from './QueryableModule.ts'
-
-export type QueryableModuleTypeCheck<T extends QueryableModule = QueryableModule> = TypeCheck<T>
-
-/** @deprecated use QueryableModuleTypeCheck instead */
-export type ModuleTypeCheck<T extends QueryableModule = QueryableModule> = TypeCheck<T>
-
-export class IsQueryableModuleFactory<T extends QueryableModule = QueryableModule> {
-  create(expectedQueries?: string[], additionalChecks?: TypeCheck<AnyObject | EmptyObject>[]): QueryableModuleTypeCheck<T> {
-    const result = (obj: AnyNonPromise, config?: TypeCheckConfig | number): obj is T => {
-      const mod = asQueryableModuleObject(obj)
-      return (
-        isQueryableModuleObject(mod, config)
-        // eslint-disable-next-line unicorn/no-array-reduce
-        && (expectedQueries?.reduce((prev, query) => prev && mod.queries.includes(query), true) ?? true)
-        // perform additional checks
-        // eslint-disable-next-line unicorn/no-array-reduce
-        && (additionalChecks?.reduce((prev, check) => prev && check(obj, config), true) ?? true)
-      )
-    }
-    return result
-  }
-}
-
-/** @deprecated use IsQueryableModuleFactory instead */
-export class IsModuleFactory<T extends QueryableModule = QueryableModule> extends IsQueryableModuleFactory<T> {}

package/src/QueryableModule/QueryableModule.ts

@@ -1,14 +0,0 @@
-import type { CreatableInstance } from '@xylabs/sdk-js'
-
-import type { ModuleEventData } from '../EventsModels/index.ts'
-import type { QueryableModuleFields } from './QueryableModuleFields.ts'
-import type { QueryableModuleParams } from './QueryableModuleParams.ts'
-
-export interface QueryableModule<TParams extends QueryableModuleParams = QueryableModuleParams,
-  TEventData extends ModuleEventData<object> = ModuleEventData<object>>
-  extends QueryableModuleFields<TParams>, CreatableInstance<TParams, TEventData> {
-}
-
-/** @deprecated use QueryableModule instead */
-export interface Module<TParams extends QueryableModuleParams = QueryableModuleParams, TEventData extends ModuleEventData<object> = ModuleEventData<object>>
-  extends QueryableModule<TParams, TEventData> {}

package/src/QueryableModule/QueryableModuleFields.ts

@@ -1,37 +0,0 @@
-import type { Address, Promisable } from '@xylabs/sdk-js'
-import type { QueryBoundWitness } from '@xyo-network/boundwitness-model'
-import type { Payload } from '@xyo-network/payload-model'
-
-import type { ModuleConfig } from '../Config/index.ts'
-import type { ModuleName } from '../ModuleIdentifier.ts'
-import type { ModuleQueryResult } from '../ModuleQueryResult.ts'
-import type { QueryableModuleParams } from './QueryableModuleParams.ts'
-
-export interface QueryableModuleFields<TParams extends QueryableModuleParams = QueryableModuleParams> {
-  address: Address
-  config: TParams['config']
-
-  /** The name (if specified) or address of the module */
-  id: string
-
-  modName?: ModuleName
-
-  params: TParams
-
-  previousHash: () => Promisable<string | undefined>
-
-  queries: string[]
-  query: <T extends QueryBoundWitness = QueryBoundWitness, TConf extends ModuleConfig = ModuleConfig>(
-    query: T,
-    payloads?: Payload[],
-    queryConfig?: TConf,
-  ) => Promisable<ModuleQueryResult>
-  queryable: <T extends QueryBoundWitness = QueryBoundWitness, TConf extends ModuleConfig = ModuleConfig>(
-    query: T,
-    payloads?: Payload[],
-    queryConfig?: TConf,
-  ) => Promisable<boolean>
-}
-
-/** @deprecated use QueryableModuleFields instead */
-export interface ModuleFields<TParams extends QueryableModuleParams = QueryableModuleParams> extends QueryableModuleFields<TParams> {}

package/src/QueryableModule/QueryableModuleFunctions.ts

@@ -1,18 +0,0 @@
-import type { Address, Promisable } from '@xylabs/sdk-js'
-import type { AccountInstance } from '@xyo-network/account-model'
-import type { ModuleManifestPayload } from '@xyo-network/manifest-model'
-import type { Payload } from '@xyo-network/payload-model'
-
-import type { ModuleQueryResult } from '../ModuleQueryResult.ts'
-import type { AddressPayload, AddressPreviousHashPayload } from '../Payload/index.ts'
-
-export interface QueryableModuleFunctions {
-  manifest: (maxDepth?: number, ignoreAddresses?: Address[]) => Promisable<ModuleManifestPayload>
-  manifestQuery: (account: AccountInstance, maxDepth?: number, ignoreAddresses?: Address[]) => Promisable<ModuleQueryResult<ModuleManifestPayload>>
-  moduleAddress: () => Promisable<(AddressPreviousHashPayload | AddressPayload)[]>
-  state: () => Promisable<Payload[]>
-  stateQuery: (account: AccountInstance) => Promisable<ModuleQueryResult>
-}
-
-/** @deprecated use QueryableModuleFunctions instead */
-export interface ModuleQueryFunctions extends QueryableModuleFunctions {}

package/src/QueryableModule/QueryableModuleParams.ts

@@ -1,20 +0,0 @@
-import type { CreatableParams } from '@xylabs/sdk-js'
-import type { AccountInstance } from '@xyo-network/account-model'
-
-import type { AnyConfigSchema, ModuleConfig } from '../Config/index.ts'
-import type { ModuleIdentifierTransformer } from '../ModuleIdentifierTransformer.ts'
-import type { ModuleStatusReporter } from '../ModuleStatusReporter.ts'
-
-export interface QueryableModuleParams<TConfig extends AnyConfigSchema<ModuleConfig> = AnyConfigSchema<ModuleConfig>> extends CreatableParams {
-  account?: AccountInstance | 'random'
-  addToResolvers?: boolean
-  additionalSigners?: AccountInstance[]
-  allowNameResolution?: boolean
-  config: Partial<TConfig>
-  ephemeralQueryAccountEnabled?: boolean
-  moduleIdentifierTransformers?: ModuleIdentifierTransformer[]
-  statusReporter?: ModuleStatusReporter
-}
-
-/** @deprecated use QueryableModuleParams instead */
-export interface ModuleParams<TConfig extends AnyConfigSchema<ModuleConfig> = AnyConfigSchema<ModuleConfig>> extends QueryableModuleParams<TConfig> {}

package/src/QueryableModule/asQueryableModule.ts

@@ -1,8 +0,0 @@
-import { AsObjectFactory } from '@xylabs/sdk-js'
-
-import { isQueryableModule } from './isQueryableModule.ts'
-
-export const asQueryableModule = AsObjectFactory.create(isQueryableModule)
-
-/** @deprecated use asQueryableModule instead */
-export const asModule = asQueryableModule

package/src/QueryableModule/asQueryableModuleObject.ts

@@ -1,8 +0,0 @@
-import { AsObjectFactory } from '@xylabs/sdk-js'
-
-import { isQueryableModuleObject } from './isQueryableModuleObject.ts'
-
-export const asQueryableModuleObject = AsObjectFactory.create(isQueryableModuleObject)
-
-/** @deprecated use asQueryableModuleObject instead */
-export const asModuleObject = asQueryableModuleObject

package/src/QueryableModule/index.ts

@@ -1,9 +0,0 @@
-export * from './asQueryableModule.ts'
-export * from './asQueryableModuleObject.ts'
-export * from './isQueryableModule.ts'
-export * from './IsQueryableModuleFactory.ts'
-export * from './isQueryableModuleObject.ts'
-export * from './QueryableModule.ts'
-export * from './QueryableModuleFields.ts'
-export * from './QueryableModuleFunctions.ts'
-export * from './QueryableModuleParams.ts'

package/src/QueryableModule/isQueryableModule.ts

@@ -1,20 +0,0 @@
-import type { TypeCheck } from '@xylabs/sdk-js'
-import type { Schema } from '@xyo-network/payload-model'
-
-import { ModuleStateQuerySchema } from '../Queries/index.ts'
-import { IsQueryableModuleFactory } from './IsQueryableModuleFactory.ts'
-import { isQueryableModuleObject } from './isQueryableModuleObject.ts'
-import type { QueryableModule } from './QueryableModule.ts'
-
-export const requiredQueryableModuleQueries: Schema[] = [ModuleStateQuerySchema]
-
-/** @deprecated use requiredQueryableModuleQueries instead */
-export const requiredModuleQueries: Schema[] = requiredQueryableModuleQueries
-
-// we do not use IsInstanceFactory here to prevent a cycle
-const factory = new IsQueryableModuleFactory<QueryableModule>()
-
-export const isQueryableModule: TypeCheck<QueryableModule> = factory.create(requiredQueryableModuleQueries, [isQueryableModuleObject])
-
-/** @deprecated use isQueryableModule instead */
-export const isModule: TypeCheck<QueryableModule> = isQueryableModule

package/src/QueryableModule/isQueryableModuleObject.ts

@@ -1,20 +0,0 @@
-import type { ObjectTypeShape, TypeCheck } from '@xylabs/sdk-js'
-import { IsObjectFactory } from '@xylabs/sdk-js'
-
-import type { QueryableModule } from './QueryableModule.ts'
-
-export const requiredQueryableModuleShape: ObjectTypeShape = {
-  address: 'string',
-  queries: 'array',
-  query: 'function',
-}
-
-/** @deprecated use requiredQueryableModuleShape instead */
-export const requiredModuleShape: ObjectTypeShape = requiredQueryableModuleShape
-
-const factory = new IsObjectFactory<QueryableModule>()
-
-export const isQueryableModuleObject: TypeCheck<QueryableModule> = factory.create(requiredQueryableModuleShape)
-
-/** @deprecated use isQueryableModuleObject instead */
-export const isModuleObject: TypeCheck<QueryableModule> = isQueryableModuleObject