@opra/common 0.23.2 → 0.24.1

package/cjs/document/utils/generate-codec.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._generateDecoder = exports.generateCodec = void 0;
+exports._generateCodec = exports.generateCodec = void 0;
 const tslib_1 = require("tslib");
 const vg = tslib_1.__importStar(require("valgen"));
 const complex_type_js_1 = require("../data-type/complex-type.js");
@@ -9,10 +9,10 @@ const mapped_type_js_1 = require("../data-type/mapped-type.js");
 const simple_type_js_1 = require("../data-type/simple-type.js");
 const union_type_js_1 = require("../data-type/union-type.js");
 function generateCodec(type, codec, options) {
-    return _generateDecoder(type, codec, options);
+    return _generateCodec(type, codec, options);
 }
 exports.generateCodec = generateCodec;
-function _generateDecoder(type, codec, options) {
+function _generateCodec(type, codec, options) {
     const schema = {};
     for (const f of type.fields.values()) {
         let fn;
@@ -20,7 +20,7 @@ function _generateDecoder(type, codec, options) {
             fn = f.type[codec];
         }
         else if (f.type instanceof complex_type_js_1.ComplexType || f.type instanceof mapped_type_js_1.MappedType || f.type instanceof union_type_js_1.UnionType) {
-            fn = _generateDecoder(f.type, codec, options);
+            fn = _generateCodec(f.type, codec, options);
         }
         /* istanbul ignore next */
         if (!fn)
@@ -36,4 +36,4 @@ function _generateDecoder(type, codec, options) {
         caseInSensitive: true,
     });
 }
-exports._generateDecoder = _generateDecoder;
+exports._generateCodec = _generateCodec;

package/cjs/exception/resource-errors/resource-not-found.error.js

@@ -10,7 +10,7 @@ const opra_exception_js_1 = require("../opra-exception.js");
 class ResourceNotFoundError extends opra_exception_js_1.OpraException {
     constructor(resource, keyValue, cause) {
         super({
-            message: (0, index_js_1.translate)(`error:RESOURCE_NOT_FOUND`, { resource: resource + (keyValue ? '@' + keyValue : '') }, `The resource '{{resource}}' not found`),
+            message: (0, index_js_1.translate)(`error:RESOURCE_NOT_FOUND`, `Resource not found`),
             severity: 'error',
             code: 'RESOURCE_NOT_FOUND',
             details: {

package/cjs/helpers/mixin-utils.js

@@ -12,11 +12,11 @@ function mergePrototype(targetProto, baseProto, filter) {
 }
 exports.mergePrototype = mergePrototype;
 // noinspection JSUnusedLocalSymbols
-function inheritPropertyInitializers(target, sourceClass, 
+function inheritPropertyInitializers(target, clazz, 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 isPropertyInherited = (key) => true) {
     try {
-        const tempInstance = new sourceClass();
+        const tempInstance = new clazz();
         const propertyNames = Object.getOwnPropertyNames(tempInstance);
         propertyNames
             .filter((propertyName) => typeof tempInstance[propertyName] !== 'undefined' &&

package/cjs/schema/opra-schema.ns.js

@@ -10,7 +10,6 @@ tslib_1.__exportStar(require("./data-type/mapped-type.interface.js"), exports);
 tslib_1.__exportStar(require("./data-type/union-type.interface.js"), exports);
 tslib_1.__exportStar(require("./resource/collection.interface.js"), exports);
 tslib_1.__exportStar(require("./resource/container.interface.js"), exports);
-tslib_1.__exportStar(require("./resource/operation.interface.js"), exports);
 tslib_1.__exportStar(require("./resource/resource.interface.js"), exports);
 tslib_1.__exportStar(require("./resource/singleton.interface.js"), exports);
 tslib_1.__exportStar(require("./resource/storage.interface.js"), exports);

package/cjs/schema/type-guards.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isContainer = exports.isStorage = exports.isSingleton = exports.isCollection = exports.isResource = exports.isEnumType = exports.isMappedType = exports.isUnionType = exports.isSimpleType = exports.isComplexType = exports.isDataType = void 0;
+exports.isContainer = exports.isStorage = exports.isSingleton = exports.isCollection = exports.isSource = exports.isEnumType = exports.isMappedType = exports.isUnionType = exports.isSimpleType = exports.isComplexType = exports.isDataType = void 0;
 const complex_type_interface_js_1 = require("./data-type/complex-type.interface.js");
 const enum_type_interface_js_1 = require("./data-type/enum-type.interface.js");
 const mapped_type_interface_js_1 = require("./data-type/mapped-type.interface.js");
@@ -39,13 +39,14 @@ function isEnumType(obj) {
     return obj && typeof obj === 'object' && obj.kind === enum_type_interface_js_1.EnumType.Kind;
 }
 exports.isEnumType = isEnumType;
-function isResource(obj) {
+function isSource(obj) {
     return obj && typeof obj === 'object' &&
         (obj.kind === container_interface_js_1.Container.Kind ||
             obj.kind === collection_interface_js_1.Collection.Kind ||
-            obj.kind === singleton_interface_js_1.Singleton.Kind);
+            obj.kind === singleton_interface_js_1.Singleton.Kind ||
+            obj.kind === storage_interface_js_1.Storage.Kind);
 }
-exports.isResource = isResource;
+exports.isSource = isSource;
 function isCollection(obj) {
     return obj && typeof obj === 'object' && obj.kind === collection_interface_js_1.Collection.Kind;
 }

package/esm/document/constants.js

@@ -1,3 +1,5 @@
-export const METADATA_KEY = Symbol.for('opra.metadata');
+export const DATATYPE_METADATA = Symbol('DATATYPE_METADATA');
+export const RESOURCE_METADATA = Symbol('RESOURCE_METADATA');
+export const DECORATOR = Symbol('DECORATOR');
 export const NAMESPACE_PATTERN = /([A-Z$_]\w+)(?::.+)?/i;
 export const TYPENAME_PATTERN = /^(.*)Type(\d*)$/;

package/esm/document/data-type/api-field.js

@@ -1,6 +1,6 @@
 import { omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY } from '../constants.js';
+import { DATATYPE_METADATA } from '../constants.js';
 import { EnumType } from './enum-type.js';
 /**
  * @class ComplexType
@@ -12,7 +12,7 @@ export const ApiField = function (...args) {
         return function (target, propertyKey) {
             if (typeof propertyKey !== 'string')
                 throw new TypeError(`Symbol properties can't be used as a field`);
-            const metadata = Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {};
+            const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target.constructor) || {};
             metadata.kind = OpraSchema.ComplexType.Kind;
             metadata.fields = metadata.fields || {};
             const designType = Reflect.getMetadata('design:type', target, propertyKey);
@@ -36,13 +36,13 @@ export const ApiField = function (...args) {
                     elemMeta.enum = enumObj;
                 }
                 else {
-                    const m = Reflect.getOwnMetadata(METADATA_KEY, options?.enum);
+                    const m = Reflect.getOwnMetadata(DATATYPE_METADATA, options?.enum);
                     if (!OpraSchema.isEnumType(m))
                         throw new TypeError(`Invalid "enum" value. Did you forget to set metadata using EnumType() method?`);
                     elemMeta.enum = options.enum;
                 }
             }
-            Reflect.defineMetadata(METADATA_KEY, omitUndefined(metadata), target.constructor);
+            Reflect.defineMetadata(DATATYPE_METADATA, omitUndefined(metadata), target.constructor);
         };
     }
     // Constructor

package/esm/document/data-type/complex-type.js

@@ -4,7 +4,7 @@ import merge from 'putil-merge';
 import { omitUndefined, ResponsiveMap } from '../../helpers/index.js';
 import { translate } from '../../i18n/index.js';
 import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY, TYPENAME_PATTERN } from '../constants.js';
+import { DATATYPE_METADATA, TYPENAME_PATTERN } from '../constants.js';
 import { ApiField } from './api-field.js';
 import { DataType } from './data-type.js';
 /**
@@ -162,10 +162,10 @@ export const ComplexType = function (...args) {
     const [options] = args;
     return function (target) {
         const name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
-        let metadata = Reflect.getOwnMetadata(METADATA_KEY, target);
+        let metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target);
         if (!metadata) {
             metadata = {};
-            Reflect.defineMetadata(METADATA_KEY, metadata, target);
+            Reflect.defineMetadata(DATATYPE_METADATA, metadata, target);
         }
         metadata.kind = OpraSchema.ComplexType.Kind;
         metadata.name = name;

package/esm/document/data-type/enum-type.js

@@ -4,7 +4,7 @@ import merge from 'putil-merge';
 import * as vg from 'valgen';
 import { omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY } from '../constants.js';
+import { DATATYPE_METADATA } from '../constants.js';
 import { DataType } from './data-type.js';
 class EnumTypeClass extends DataType {
     constructor(document, init) {
@@ -40,20 +40,20 @@ export const EnumType = function (...args) {
         return;
     }
     // Injector
-    const [source, options] = args;
-    const values = Array.isArray(source)
-        ? source.reduce((obj, v) => {
+    const [enumSource, options] = args;
+    const values = Array.isArray(enumSource)
+        ? enumSource.reduce((obj, v) => {
             obj[v] = v;
             return obj;
         }, {})
-        : source;
+        : enumSource;
     const metadata = {
         kind: OpraSchema.EnumType.Kind,
         values
     };
     if (options)
         Object.assign(metadata, omit(options, ['kind', 'values']));
-    Reflect.defineMetadata(METADATA_KEY, metadata, source);
+    Reflect.defineMetadata(DATATYPE_METADATA, metadata, enumSource);
     return values;
 };
 EnumType.prototype = EnumTypeClass.prototype;

package/esm/document/data-type/mapped-type.js

@@ -2,7 +2,7 @@ import 'reflect-metadata';
 import merge from 'putil-merge';
 import { inheritPropertyInitializers, mergePrototype, omitUndefined, ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY } from '../constants.js';
+import { DATATYPE_METADATA } from '../constants.js';
 import { DataType } from './data-type.js';
 class MappedTypeClass extends DataType {
     constructor(document, init) {
@@ -44,30 +44,30 @@ export const MappedType = function (...args) {
         return;
     }
     // MappedType helper
-    const [source, options] = args;
+    const [mappedSource, options] = args;
     const isInheritedPredicate = getIsInheritedPredicateFn(options.pick, options.omit);
     class MappedClass {
         constructor() {
-            inheritPropertyInitializers(this, source, isInheritedPredicate);
+            inheritPropertyInitializers(this, mappedSource, isInheritedPredicate);
         }
     }
-    mergePrototype(MappedClass.prototype, source.prototype);
+    mergePrototype(MappedClass.prototype, mappedSource.prototype);
     // const mappedTypeMetadata: MappedType.TypeMapping[] = [];
-    const m = Reflect.getOwnMetadata(METADATA_KEY, source);
+    const m = Reflect.getOwnMetadata(DATATYPE_METADATA, mappedSource);
     if (!m)
-        throw new TypeError(`Class "${source}" doesn't have datatype metadata information`);
+        throw new TypeError(`Class "${mappedSource}" doesn't have datatype metadata information`);
     if (!(m.kind === OpraSchema.ComplexType.Kind))
-        throw new TypeError(`Class "${source}" is not a ${OpraSchema.ComplexType.Kind}`);
+        throw new TypeError(`Class "${mappedSource}" is not a ${OpraSchema.ComplexType.Kind}`);
     const metadata = {
         kind: 'MappedType',
-        type: source
+        type: mappedSource
     };
     if (options.pick)
         metadata.pick = options.pick;
     if (options.omit)
         metadata.omit = options.omit;
-    Reflect.defineMetadata(METADATA_KEY, metadata, MappedClass);
-    MappedType._applyMixin(MappedClass, source, {
+    Reflect.defineMetadata(DATATYPE_METADATA, metadata, MappedClass);
+    MappedType._applyMixin(MappedClass, mappedSource, {
         ...options,
         isInheritedPredicate
     });

package/esm/document/data-type/simple-type.js

@@ -3,7 +3,7 @@ import omit from 'lodash.omit';
 import merge from 'putil-merge';
 import * as vg from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY, TYPENAME_PATTERN } from '../constants.js';
+import { DATATYPE_METADATA, TYPENAME_PATTERN } from '../constants.js';
 import { DataType } from './data-type.js';
 /**
  * @class SimpleType
@@ -41,12 +41,12 @@ export const SimpleType = function (...args) {
     return function (target) {
         let name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
         name = name.charAt(0).toLowerCase() + name.substring(1);
-        const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
+        const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target) || {};
         metadata.kind = OpraSchema.SimpleType.Kind;
         metadata.name = name;
         if (options)
             Object.assign(metadata, omit(options, ['kind', 'name']));
-        Reflect.defineMetadata(METADATA_KEY, metadata, target);
+        Reflect.defineMetadata(DATATYPE_METADATA, metadata, target);
     };
 };
 SimpleType.prototype = SimpleTypeClass.prototype;

package/esm/document/data-type/union-type.js

@@ -2,7 +2,7 @@ import 'reflect-metadata';
 import merge from 'putil-merge';
 import { inheritPropertyInitializers, mergePrototype, omitUndefined, ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY } from '../constants.js';
+import { DATATYPE_METADATA } from '../constants.js';
 import { ComplexType } from './complex-type.js';
 import { DataType } from './data-type.js';
 import { MappedType } from './mapped-type.js';
@@ -59,9 +59,9 @@ export const UnionType = function (...args) {
         kind: OpraSchema.UnionType.Kind,
         types: []
     };
-    Reflect.defineMetadata(METADATA_KEY, metadata, UnionClass);
+    Reflect.defineMetadata(DATATYPE_METADATA, metadata, UnionClass);
     for (const c of clasRefs) {
-        const itemMeta = Reflect.getMetadata(METADATA_KEY, c);
+        const itemMeta = Reflect.getMetadata(DATATYPE_METADATA, c);
         if (!(itemMeta && (itemMeta.kind === OpraSchema.ComplexType.Kind || itemMeta.kind === OpraSchema.UnionType.Kind ||
             itemMeta.kind === OpraSchema.MappedType.Kind)))
             throw new TypeError(`Class "${c.name}" is not a ${OpraSchema.ComplexType.Kind}, ${OpraSchema.UnionType.Kind} or ${OpraSchema.MappedType.Kind}`);

package/esm/document/factory/create-document.js

@@ -27,11 +27,11 @@ export async function createDocument(init, options) {
         this.curPath.push('resources');
         if (Array.isArray(init.resources)) {
             for (const res of init.resources)
-                await this.importResourceClass(res);
+                await this.importSourceClass(res);
         }
         else
-            this.resourceQueue.setAll(init.resources);
-        await this.processResourceQueue();
+            this.sourceQueue.setAll(init.resources);
+        await this.processSourceQueue();
         this.curPath.pop();
     }
     this.document.types.sort();

package/esm/document/factory/factory.js

@@ -5,7 +5,7 @@ import { addReferences } from './add-references.js';
 import { createBuiltinTypeDocument, createDocument, createDocumentFromUrl } from './create-document.js';
 import { extractCollectionSchema, extractSingletonSchema, importResourceClass } from './import-resource-class.js';
 import { extractComplexTypeSchema, extractEnumTypeSchema, extractFieldSchema, extractMappedTypeSchema, extractSimpleTypeSchema, extractUnionTypeSchema, importTypeClass } from './import-type-class.js';
-import { createCollectionResource, createFileResource, createSingletonResource, processResourceQueue } from './process-resources.js';
+import { createCollectionResource, createSingletonResource, createStorageResource, processSourceQueue } from './process-resources.js';
 import { addDataType, createDataTypeInstance, processTypes } from './process-types.js';
 /**
  * @class DocumentFactory
@@ -14,7 +14,7 @@ export class DocumentFactory {
     constructor() {
         this.document = new ApiDocument();
         this.typeQueue = new ResponsiveMap();
-        this.resourceQueue = new ResponsiveMap();
+        this.sourceQueue = new ResponsiveMap();
         this.circularRefs = new ResponsiveMap();
         this.curPath = [];
         this.cache = new Map();
@@ -52,11 +52,11 @@ DocumentFactory.designTypeMap = new Map();
     _a.prototype.processTypes = processTypes;
     _a.prototype.createDataTypeInstance = createDataTypeInstance;
     _a.prototype.addDataType = addDataType;
-    _a.prototype.importResourceClass = importResourceClass;
+    _a.prototype.importSourceClass = importResourceClass;
     _a.prototype.extractSingletonSchema = extractSingletonSchema;
     _a.prototype.extractCollectionSchema = extractCollectionSchema;
-    _a.prototype.processResourceQueue = processResourceQueue;
-    _a.prototype.createCollectionResource = createCollectionResource;
-    _a.prototype.createSingletonResource = createSingletonResource;
-    _a.prototype.createFileResource = createFileResource;
+    _a.prototype.processSourceQueue = processSourceQueue;
+    _a.prototype.createCollectionSource = createCollectionResource;
+    _a.prototype.createSingletonSource = createSingletonResource;
+    _a.prototype.createFileSource = createStorageResource;
 })();

package/esm/document/factory/import-resource-class.js

@@ -1,16 +1,16 @@
 import 'reflect-metadata';
 import { cloneObject, resolveClass, resolveThunk } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY } from '../constants.js';
+import { RESOURCE_METADATA } from '../constants.js';
 export async function importResourceClass(thunk) {
-    const { document, resourceQueue, cache } = this;
+    const { document, sourceQueue, cache } = this;
     const controller = await resolveThunk(thunk);
     const cached = cache.get(controller);
     if (cached)
         return cached;
     const ctor = typeof thunk === 'function' ? thunk : Object.getPrototypeOf(thunk).constructor;
-    let metadata = Reflect.getMetadata(METADATA_KEY, ctor);
-    if (!metadata && OpraSchema.isResource(metadata))
+    let metadata = Reflect.getMetadata(RESOURCE_METADATA, ctor);
+    if (!metadata && OpraSchema.isSource(metadata))
         throw new TypeError(`Class "${ctor.name}" doesn't have a valid Resource metadata`);
     // const controller = typeof thunk === 'function' ? new ctor() : thunk;
     // Clone metadata to prevent changing its contents
@@ -34,7 +34,7 @@ export async function importResourceClass(thunk) {
         await this.extractSingletonSchema(schema, ctor, metadata, controller);
     if (OpraSchema.isCollection(schema))
         await this.extractCollectionSchema(schema, ctor, metadata, controller);
-    resourceQueue.set(metadata.name, schema);
+    sourceQueue.set(metadata.name, schema);
 }
 export async function extractSingletonSchema(
 // eslint-disable-next-line @typescript-eslint/no-unused-vars

package/esm/document/factory/import-type-class.js

@@ -1,7 +1,7 @@
 import { validator } from 'valgen';
 import { cloneObject, isConstructor, resolveThunk } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY } from '../constants.js';
+import { DATATYPE_METADATA } from '../constants.js';
 export async function importTypeClass(typeThunk) {
     const { document, typeQueue, cache } = this;
     const thunk = await resolveThunk(typeThunk);
@@ -11,7 +11,7 @@ export async function importTypeClass(typeThunk) {
     const dt = document.getDataType(thunk, true);
     if (dt && dt.name)
         return dt.name;
-    const metadata = Reflect.getMetadata(METADATA_KEY, thunk);
+    const metadata = Reflect.getMetadata(DATATYPE_METADATA, thunk);
     if (!(metadata && OpraSchema.isDataType(metadata))) {
         // If thunk is a Type class
         if (isConstructor(thunk))
@@ -48,7 +48,7 @@ export async function importTypeClass(typeThunk) {
     const enumObject = thunk;
     if (OpraSchema.isEnumType(schema)) {
         let baseType;
-        if (metadata.base && Reflect.hasMetadata(METADATA_KEY, metadata.base)) {
+        if (metadata.base && Reflect.hasMetadata(DATATYPE_METADATA, metadata.base)) {
             baseType = await this.importTypeClass(metadata.base);
         }
         schema.base = baseType;
@@ -62,7 +62,7 @@ export async function extractSimpleTypeSchema(target, ctor,
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 metadata) {
     const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
-    if (Reflect.hasMetadata(METADATA_KEY, baseClass))
+    if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass))
         target.base = await this.importTypeClass(baseClass);
     if (typeof ctor.prototype.decode === 'function')
         target.decoder = validator(metadata.name, ctor.prototype.decode);
@@ -71,7 +71,7 @@ metadata) {
 }
 export async function extractComplexTypeSchema(target, ctor, metadata) {
     const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
-    if (Reflect.hasMetadata(METADATA_KEY, baseClass))
+    if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass))
         target.base = await this.importTypeClass(baseClass);
     target.ctor = target.ctor || ctor;
     // Fields

package/esm/document/factory/process-resources.js

@@ -2,26 +2,26 @@ import { OpraSchema } from '../../schema/index.js';
 import { Collection } from '../resource/collection.js';
 import { Singleton } from '../resource/singleton.js';
 import { Storage } from '../resource/storage.js';
-export async function processResourceQueue() {
-    const { document, resourceQueue } = this;
-    const resourceNames = Array.from(resourceQueue.keys());
-    for (const name of resourceNames) {
-        const schema = resourceQueue.get(name);
+export async function processSourceQueue() {
+    const { document, sourceQueue } = this;
+    const sourceNames = Array.from(sourceQueue.keys());
+    for (const name of sourceNames) {
+        const schema = sourceQueue.get(name);
         if (!schema)
             continue;
         try {
             if (OpraSchema.isCollection(schema)) {
-                const resource = await this.createCollectionResource(name, schema);
+                const resource = await this.createCollectionSource(name, schema);
                 document.resources.set(name, resource);
                 continue;
             }
             if (OpraSchema.isSingleton(schema)) {
-                const resource = await this.createSingletonResource(name, schema);
+                const resource = await this.createSingletonSource(name, schema);
                 document.resources.set(name, resource);
                 continue;
             }
             if (OpraSchema.isStorage(schema)) {
-                const resource = await this.createFileResource(name, schema);
+                const resource = await this.createFileSource(name, schema);
                 document.resources.set(name, resource);
                 continue;
             }
@@ -53,7 +53,7 @@ export async function createSingletonResource(name, schema) {
     };
     return new Singleton(document, initArgs);
 }
-export async function createFileResource(name, schema) {
+export async function createStorageResource(name, schema) {
     const { document } = this;
     const initArgs = {
         ...schema,

package/esm/document/index.js

@@ -13,5 +13,6 @@ export * from './resource/resource.js';
 export * from './resource/collection.js';
 export * from './resource/singleton.js';
 export * from './resource/storage.js';
-export * from './interfaces/collection-resource.interface.js';
-export * from './interfaces/singleton-resource.interface.js';
+export * from './interfaces/collection.interface.js';
+export * from './interfaces/singleton.interface.js';
+export * from './interfaces/storage.interface.js';

package/esm/document/resource/action.js

@@ -0,0 +1,8 @@
+export class Action {
+    constructor(init) {
+        this.name = init.name;
+    }
+    exportSchema() {
+        return {};
+    }
+}