@opra/common 0.4.0 → 0.6.0

package/cjs/schema/implementation/query/collection-get-query.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionGetQuery = void 0;
+const normalize_field_array_util_js_1 = require("../../utils/normalize-field-array.util.js");
+class CollectionGetQuery {
+    resource;
+    kind = 'CollectionGetQuery';
+    method = 'get';
+    operation = 'read';
+    keyValue;
+    pick;
+    omit;
+    include;
+    child;
+    constructor(resource, keyValue, options) {
+        this.resource = resource;
+        if (resource.keyFields.length > 1) {
+            if (typeof keyValue !== 'object')
+                throw new Error(`You must provide an key/value object for all key fields (${resource.keyFields})`);
+            resource.keyFields.reduce((o, k) => {
+                o[k] = keyValue[k];
+                return o;
+            }, {});
+        }
+        else
+            this.keyValue = resource.dataType.getFieldType(resource.keyFields[0]).parse(keyValue);
+        if (options?.pick)
+            this.pick = (0, normalize_field_array_util_js_1.normalizeFieldArray)(resource.document, resource.dataType, options.pick);
+        if (options?.omit)
+            this.omit = (0, normalize_field_array_util_js_1.normalizeFieldArray)(resource.document, resource.dataType, options.omit);
+        if (options?.include)
+            this.include = (0, normalize_field_array_util_js_1.normalizeFieldArray)(resource.document, resource.dataType, options.include);
+    }
+    get dataType() {
+        return this.resource.dataType;
+    }
+}
+exports.CollectionGetQuery = CollectionGetQuery;

package/cjs/schema/implementation/query/collection-search-query.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionSearchQuery = void 0;
+const index_js_1 = require("../../../exception/index.js");
+const index_js_2 = require("../../../filter/index.js");
+const index_js_3 = require("../../../i18n/index.js");
+const normalize_field_array_util_js_1 = require("../../utils/normalize-field-array.util.js");
+class CollectionSearchQuery {
+    resource;
+    kind = 'CollectionSearchQuery';
+    method = 'search';
+    operation = 'read';
+    pick;
+    omit;
+    include;
+    filter;
+    limit;
+    skip;
+    distinct;
+    count;
+    sort;
+    constructor(resource, options) {
+        this.resource = resource;
+        if (options?.pick)
+            this.pick = (0, normalize_field_array_util_js_1.normalizeFieldArray)(resource.document, resource.dataType, options.pick);
+        if (options?.omit)
+            this.omit = (0, normalize_field_array_util_js_1.normalizeFieldArray)(resource.document, resource.dataType, options.omit);
+        if (options?.include)
+            this.include = (0, normalize_field_array_util_js_1.normalizeFieldArray)(resource.document, resource.dataType, options.include);
+        this.filter = typeof options?.filter === 'string' ? (0, index_js_2.parseFilter)(options.filter) : options?.filter;
+        this.limit = options?.limit;
+        this.skip = options?.skip;
+        this.distinct = options?.distinct;
+        this.count = options?.count;
+        if (options?.sort) {
+            this.sort = (0, normalize_field_array_util_js_1.normalizeFieldArray)(resource.document, resource.dataType, options.sort);
+            const search = resource.search;
+            if (search && typeof search === 'object') {
+                const sortFields = search.sortFields;
+                if (sortFields) {
+                    this.sort.forEach(field => {
+                        if (!sortFields.find(x => x === field))
+                            throw new index_js_1.BadRequestError({
+                                message: (0, index_js_3.translate)('error:UNACCEPTED_SORT_FIELD', { field }, `Field '${field}' is not available for sort operation`),
+                            });
+                    });
+                }
+            }
+        }
+    }
+    get dataType() {
+        return this.resource.dataType;
+    }
+}
+exports.CollectionSearchQuery = CollectionSearchQuery;

package/cjs/schema/implementation/query/collection-update-many-query.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionUpdateManyQuery = void 0;
+const index_js_1 = require("../../../filter/index.js");
+class CollectionUpdateManyQuery {
+    resource;
+    data;
+    kind = 'CollectionUpdateManyQuery';
+    method = 'updateMany';
+    operation = 'update';
+    filter;
+    constructor(resource, data, options) {
+        this.resource = resource;
+        this.data = data;
+        this.filter = typeof options?.filter === 'string' ? (0, index_js_1.parseFilter)(options.filter) : options?.filter;
+    }
+    get dataType() {
+        return this.resource.dataType;
+    }
+}
+exports.CollectionUpdateManyQuery = CollectionUpdateManyQuery;

package/cjs/schema/implementation/query/collection-update-query.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionUpdateQuery = void 0;
+const normalize_field_array_util_js_1 = require("../../utils/normalize-field-array.util.js");
+class CollectionUpdateQuery {
+    resource;
+    data;
+    kind = 'CollectionUpdateQuery';
+    method = 'update';
+    operation = 'update';
+    keyValue;
+    pick;
+    omit;
+    include;
+    constructor(resource, keyValue, data, options) {
+        this.resource = resource;
+        this.data = data;
+        if (resource.keyFields.length > 1) {
+            if (typeof keyValue !== 'object')
+                throw new Error(`You must provide an key/value object for all key fields (${resource.keyFields})`);
+            resource.keyFields.reduce((o, k) => {
+                o[k] = keyValue[k];
+                return o;
+            }, {});
+        }
+        else
+            this.keyValue = resource.dataType.getFieldType(resource.keyFields[0]).parse(keyValue);
+        if (options?.pick)
+            this.pick = (0, normalize_field_array_util_js_1.normalizeFieldArray)(resource.document, resource.dataType, options.pick);
+        if (options?.omit)
+            this.omit = (0, normalize_field_array_util_js_1.normalizeFieldArray)(resource.document, resource.dataType, options.omit);
+        if (options?.include)
+            this.include = (0, normalize_field_array_util_js_1.normalizeFieldArray)(resource.document, resource.dataType, options.include);
+    }
+    get dataType() {
+        return this.resource.dataType;
+    }
+}
+exports.CollectionUpdateQuery = CollectionUpdateQuery;

package/cjs/schema/implementation/query/field-get-query.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldGetQuery = void 0;
+const normalize_field_array_util_js_1 = require("../../utils/normalize-field-array.util.js");
+const complex_type_js_1 = require("../data-type/complex-type.js");
+class FieldGetQuery {
+    parent;
+    resource;
+    kind = 'FieldGetQuery';
+    method = 'get';
+    operation = 'read';
+    fieldName;
+    field;
+    path;
+    dataType;
+    parentType;
+    pick;
+    omit;
+    include;
+    child;
+    constructor(parent, fieldName, options) {
+        this.parent = parent;
+        this.resource = parent.resource;
+        const parentType = options?.castingType || parent.dataType;
+        if (!parentType || !(parentType instanceof complex_type_js_1.ComplexType))
+            throw new TypeError(`Data type of parent query is not a ComplexType`);
+        this.parentType = parentType;
+        this.field = parentType.additionalFields
+            ? parentType.fields.get(fieldName)
+            : parentType.getField(fieldName);
+        this.fieldName = this.field ? this.field.name : fieldName;
+        this.dataType = this.resource.document.getDataType(this.field ? (this.field.type || 'string') : 'object');
+        this.path = (parent instanceof FieldGetQuery
+            ? parent.path + '.' : '') + this.fieldName;
+        if (this.dataType instanceof complex_type_js_1.ComplexType) {
+            if (options?.pick)
+                this.pick = (0, normalize_field_array_util_js_1.normalizeFieldArray)(this.resource.document, this.dataType, options.pick, this.path);
+            if (options?.omit)
+                this.omit = (0, normalize_field_array_util_js_1.normalizeFieldArray)(this.resource.document, this.dataType, options.omit, this.path);
+            if (options?.include)
+                this.include = (0, normalize_field_array_util_js_1.normalizeFieldArray)(this.resource.document, this.dataType, options.include, this.path);
+        }
+    }
+}
+exports.FieldGetQuery = FieldGetQuery;

package/cjs/schema/implementation/query/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isChildFieldQuery = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./collection-create-query.js"), exports);
+tslib_1.__exportStar(require("./collection-count-query.js"), exports);
+tslib_1.__exportStar(require("./collection-delete-many-query.js"), exports);
+tslib_1.__exportStar(require("./collection-delete-query.js"), exports);
+tslib_1.__exportStar(require("./collection-delete-many-query.js"), exports);
+tslib_1.__exportStar(require("./collection-get-query.js"), exports);
+tslib_1.__exportStar(require("./field-get-query.js"), exports);
+tslib_1.__exportStar(require("./singleton-get-query.js"), exports);
+tslib_1.__exportStar(require("./collection-search-query.js"), exports);
+tslib_1.__exportStar(require("./collection-update-many-query.js"), exports);
+tslib_1.__exportStar(require("./collection-update-query.js"), exports);
+function isChildFieldQuery(query) {
+    return query &&
+        (query.kind === 'SingletonGetQuery' ||
+            query.kind === 'CollectionGetQuery' ||
+            query.kind === 'FieldGetQuery');
+}
+exports.isChildFieldQuery = isChildFieldQuery;

package/cjs/schema/implementation/query/singleton-get-query.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingletonGetQuery = void 0;
+const normalize_field_array_util_js_1 = require("../../utils/normalize-field-array.util.js");
+class SingletonGetQuery {
+    resource;
+    kind = 'SingletonGetQuery';
+    method = 'get';
+    operation = 'read';
+    pick;
+    omit;
+    include;
+    child;
+    constructor(resource, options) {
+        this.resource = resource;
+        if (options?.pick)
+            this.pick = (0, normalize_field_array_util_js_1.normalizeFieldArray)(resource.document, resource.dataType, options.pick);
+        if (options?.omit)
+            this.omit = (0, normalize_field_array_util_js_1.normalizeFieldArray)(resource.document, resource.dataType, options.omit);
+        if (options?.include)
+            this.include = (0, normalize_field_array_util_js_1.normalizeFieldArray)(resource.document, resource.dataType, options.include);
+    }
+    get dataType() {
+        return this.resource.dataType;
+    }
+}
+exports.SingletonGetQuery = SingletonGetQuery;

package/cjs/schema/implementation/resource/collection-resource-info.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionResourceInfo = void 0;
+const constants_js_1 = require("../../constants.js");
+const normalize_field_array_util_js_1 = require("../../utils/normalize-field-array.util.js");
+const resource_info_js_1 = require("./resource-info.js");
+class CollectionResourceInfo extends resource_info_js_1.ResourceInfo {
+    dataType;
+    constructor(document, name, dataType, metadata) {
+        if (!metadata.keyFields)
+            throw new TypeError(`You should provide key fields for ${name}`);
+        super(document, name, metadata);
+        metadata.keyFields = Array.isArray(metadata.keyFields) ? metadata.keyFields : [metadata.keyFields];
+        metadata.keyFields.forEach(f => dataType.getField(f));
+        this.dataType = dataType;
+        if (metadata.search && metadata.search.sortFields) {
+            metadata.search.sortFields = (0, normalize_field_array_util_js_1.normalizeFieldArray)(document, dataType, metadata.search.sortFields);
+        }
+    }
+    get keyFields() {
+        return this.metadata.keyFields;
+    }
+    get create() {
+        return this.metadata.create;
+    }
+    get count() {
+        return this.metadata.count;
+    }
+    get delete() {
+        return this.metadata.delete;
+    }
+    get deleteMany() {
+        return this.metadata.deleteMany;
+    }
+    get get() {
+        return this.metadata.get;
+    }
+    get update() {
+        return this.metadata.update;
+    }
+    get updateMany() {
+        return this.metadata.updateMany;
+    }
+    get search() {
+        return this.metadata.search;
+    }
+    getSchema(jsonOnly) {
+        const out = super.getSchema(jsonOnly);
+        if (out.keyFields.length < 2)
+            out.keyFields = out.keyFields[0];
+        for (const k of constants_js_1.collectionMethods) {
+            if (typeof out[k] === 'object' && !Object.keys(out[k]).length)
+                out[k] = true;
+        }
+        return out;
+    }
+}
+exports.CollectionResourceInfo = CollectionResourceInfo;

package/cjs/schema/implementation/resource/container-resource-info.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerResourceInfo = void 0;
+const collection_resource_info_js_1 = require("./collection-resource-info.js");
+const resource_info_js_1 = require("./resource-info.js");
+const singleton_resource_info_js_1 = require("./singleton-resource-info.js");
+class ContainerResourceInfo extends resource_info_js_1.ResourceInfo {
+    constructor(service, name, metadata) {
+        super(service, name, metadata);
+    }
+    getResource(name) {
+        const t = this.metadata.resources[name];
+        if (!t)
+            throw new Error(`Resource "${name}" does not exists`);
+        return t;
+    }
+    getCollectionResource(name) {
+        const t = this.getResource(name);
+        if (!(t instanceof collection_resource_info_js_1.CollectionResourceInfo))
+            throw new Error(`"${name}" is not a Collection Resource`);
+        return t;
+    }
+    getSingletonResource(name) {
+        const t = this.getResource(name);
+        if (!(t instanceof singleton_resource_info_js_1.SingletonResourceInfo))
+            throw new Error(`"${name}" is not a SingletonResource`);
+        return t;
+    }
+}
+exports.ContainerResourceInfo = ContainerResourceInfo;

package/cjs/schema/implementation/resource/resource-info.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceInfo = void 0;
+const clone_object_util_js_1 = require("../../utils/clone-object.util.js");
+const inspect_util_js_1 = require("../../utils/inspect.util.js");
+class ResourceInfo {
+    metadata;
+    document;
+    name;
+    path;
+    constructor(document, name, metadata) {
+        this.document = document;
+        this.name = name;
+        this.metadata = metadata;
+    }
+    get instance() {
+        return this.metadata.instance;
+    }
+    get kind() {
+        return this.metadata.kind;
+    }
+    get description() {
+        return this.metadata.description;
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    validateQueryOptions() {
+        //
+    }
+    getSchema(jsonOnly) {
+        return (0, clone_object_util_js_1.cloneObject)(this.metadata, jsonOnly);
+    }
+    [inspect_util_js_1.nodeInspectCustom]() {
+        return `[${inspect_util_js_1.colorFgYellow + Object.getPrototypeOf(this).constructor.name + inspect_util_js_1.colorReset}` +
+            ` ${inspect_util_js_1.colorFgMagenta + this.name + inspect_util_js_1.colorReset}]`;
+    }
+}
+exports.ResourceInfo = ResourceInfo;

package/cjs/schema/implementation/resource/singleton-resource-info.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingletonResourceInfo = void 0;
+const constants_js_1 = require("../../constants.js");
+const complex_type_js_1 = require("../data-type/complex-type.js");
+const resource_info_js_1 = require("./resource-info.js");
+class SingletonResourceInfo extends resource_info_js_1.ResourceInfo {
+    dataType;
+    constructor(document, name, dataType, metadata) {
+        // noinspection SuspiciousTypeOfGuard
+        if (!(dataType instanceof complex_type_js_1.ComplexType))
+            throw new TypeError(`You should provide a ComplexType as "dataType" argument`);
+        super(document, name, metadata);
+        this.dataType = dataType;
+    }
+    get create() {
+        return this.metadata.create;
+    }
+    get delete() {
+        return this.metadata.delete;
+    }
+    get get() {
+        return this.metadata.get;
+    }
+    get update() {
+        return this.metadata.update;
+    }
+    getSchema(jsonOnly) {
+        const out = super.getSchema(jsonOnly);
+        for (const k of constants_js_1.singletonMethods) {
+            if (typeof out[k] === 'object' && !Object.keys(out[k]).length)
+                out[k] = true;
+        }
+        return out;
+    }
+}
+exports.SingletonResourceInfo = SingletonResourceInfo;

package/cjs/schema/implementation/schema-builder/extract-resource-metadata.util.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractResourceSchema = void 0;
+const constants_js_1 = require("../../constants.js");
+const opra_schema_definition_js_1 = require("../../opra-schema.definition.js");
+const clone_object_util_js_1 = require("../../utils/clone-object.util.js");
+async function extractResourceSchema(instance) {
+    const proto = Object.getPrototypeOf(instance);
+    const ctor = proto.constructor;
+    const metadata = Reflect.getMetadata(constants_js_1.RESOURCE_METADATA, ctor);
+    if (!metadata)
+        throw new TypeError(`Class "${ctor.name}" doesn't have "Resource" metadata information`);
+    const schema = (0, clone_object_util_js_1.cloneObject)(metadata);
+    schema.instance = instance;
+    schema.name = metadata.name || ctor.name.replace(/(Resource|Controller)$/, '');
+    if (opra_schema_definition_js_1.OpraSchema.isCollectionResource(metadata))
+        return await processCollectionResource(schema);
+    if (opra_schema_definition_js_1.OpraSchema.isSingletonResource(metadata))
+        return await processSingletonResource(schema);
+    throw new TypeError(`Invalid Resource metadata`);
+}
+exports.extractResourceSchema = extractResourceSchema;
+async function processCollectionResource(schema) {
+    const instance = schema.instance;
+    const proto = Object.getPrototypeOf(schema.instance);
+    let methodMetadata;
+    let fn;
+    const locateFn = (inst, methodName) => {
+        fn = inst[methodName];
+        methodMetadata = Reflect.getMetadata(constants_js_1.RESOLVER_METADATA, inst, methodName);
+        if (fn == null) {
+            if (methodMetadata) {
+                inst = Object.getPrototypeOf(inst);
+                fn = inst[methodName];
+            }
+        }
+    };
+    for (const methodName of constants_js_1.collectionMethods) {
+        locateFn(instance, methodName);
+        if (typeof fn !== 'function')
+            continue;
+        const info = schema[methodName] = {
+            ...methodMetadata
+        };
+        if (!Reflect.hasMetadata(constants_js_1.IGNORE_RESOLVER_METHOD, proto.constructor, methodName)) {
+            info.handler = fn.bind(instance);
+            fn = instance['pre_' + methodName];
+            if (typeof fn === 'function')
+                schema['pre_' + methodName] = fn.bind(instance);
+        }
+    }
+    return schema;
+}
+async function processSingletonResource(schema) {
+    const instance = schema.instance;
+    const proto = Object.getPrototypeOf(schema.instance);
+    let methodMetadata;
+    let fn;
+    const locateFn = (inst, methodName) => {
+        fn = inst[methodName];
+        methodMetadata = Reflect.getMetadata(constants_js_1.RESOLVER_METADATA, inst, methodName);
+        if (fn == null) {
+            if (methodMetadata) {
+                inst = Object.getPrototypeOf(inst);
+                fn = inst[methodName];
+            }
+        }
+    };
+    for (const methodName of constants_js_1.singletonMethods) {
+        locateFn(instance, methodName);
+        if (typeof fn !== 'function')
+            continue;
+        const info = schema[methodName] = {
+            ...methodMetadata
+        };
+        if (!Reflect.hasMetadata(constants_js_1.IGNORE_RESOLVER_METHOD, proto.constructor, methodName)) {
+            info.handler = fn.bind(instance);
+            fn = instance['pre_' + methodName];
+            if (typeof fn === 'function')
+                schema['pre_' + methodName] = fn.bind(instance);
+        }
+    }
+    return schema;
+}

package/cjs/schema/implementation/schema-builder/extract-type-metadata.util.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDataTypeSchema = void 0;
+const tslib_1 = require("tslib");
+const Optionals = tslib_1.__importStar(require("@opra/optionals"));
+const constants_js_1 = require("../../constants.js");
+const opra_schema_definition_js_1 = require("../../opra-schema.definition.js");
+const clone_object_util_js_1 = require("../../utils/clone-object.util.js");
+const builtin_data_types_js_1 = require("../data-type/builtin-data-types.js");
+async function extractDataTypeSchema(ctor) {
+    const metadata = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, ctor);
+    if (!metadata)
+        throw new TypeError(`Class "${ctor}" doesn't have "DataType" metadata information`);
+    if (opra_schema_definition_js_1.OpraSchema.isComplexType(metadata))
+        return await extractComplexTypeSchema(ctor, metadata);
+    if (opra_schema_definition_js_1.OpraSchema.isSimpleType(metadata))
+        return await extractSimpleTypeSchema(ctor, metadata);
+    throw new TypeError(`Invalid DataType metadata`);
+}
+exports.extractDataTypeSchema = extractDataTypeSchema;
+async function extractSimpleTypeSchema(ctor, metadata) {
+    const out = (0, clone_object_util_js_1.cloneObject)(metadata);
+    out.ctor = ctor;
+    return out;
+}
+async function extractComplexTypeSchema(ctor, metadata) {
+    const out = (0, clone_object_util_js_1.cloneObject)(metadata);
+    out.ctor = ctor;
+    const mappedTypeMetadata = Reflect.getMetadata(constants_js_1.MAPPED_TYPE_METADATA, ctor);
+    if (mappedTypeMetadata) {
+        out.extends = [...mappedTypeMetadata.map(x => (0, clone_object_util_js_1.cloneObject)(x))];
+    }
+    const fields = Reflect.getMetadata(constants_js_1.COMPLEXTYPE_FIELDS, ctor);
+    if (fields) {
+        out.fields = (0, clone_object_util_js_1.cloneObject)(fields);
+        for (const [fieldName, field] of Object.entries(out.fields)) {
+            if (typeof field.type === 'function') {
+                const type = builtin_data_types_js_1.primitiveClasses.get(field.type);
+                if (type)
+                    field.type = type;
+            }
+            let sqbField;
+            if (Optionals.SqbConnect) {
+                const { EntityMetadata, isAssociationField } = Optionals.SqbConnect;
+                const meta = EntityMetadata.get(ctor);
+                sqbField = meta && EntityMetadata.getField(meta, fieldName);
+                if (sqbField) {
+                    if (field.type === Function || field.type === 'object' ||
+                        field.type === Object || field.type === 'any') {
+                        field.type = 'any';
+                        if (isAssociationField(sqbField)) {
+                            if (!sqbField.association.returnsMany())
+                                delete field.isArray;
+                            const trg = await sqbField.association.resolveTarget();
+                            if (trg) {
+                                field.type = trg.ctor;
+                            }
+                        }
+                    }
+                    if (sqbField.exclusive && field.exclusive === undefined)
+                        field.exclusive = sqbField.exclusive;
+                }
+            }
+            if (sqbField && sqbField.kind === 'column') {
+                const DataType = Optionals.SqbConnect.DataType;
+                if (field.type === 'number' || field.type === Number) {
+                    switch (sqbField.dataType) {
+                        case DataType.INTEGER:
+                        case DataType.SMALLINT:
+                            field.type = 'integer';
+                            break;
+                        case DataType.BIGINT:
+                            field.type = 'bigint';
+                            break;
+                    }
+                }
+                else if (field.type === 'string' || field.type === String) {
+                    switch (sqbField.dataType) {
+                        case DataType.GUID:
+                            field.type = 'guid';
+                            break;
+                    }
+                }
+                if (sqbField.notNull && field.required === undefined)
+                    field.required = sqbField.notNull;
+                if (sqbField.exclusive && field.exclusive === undefined)
+                    field.exclusive = sqbField.exclusive;
+                if (sqbField.default !== undefined && field.default === undefined)
+                    field.default = sqbField.default;
+            }
+        }
+    }
+    return out;
+}

package/cjs/schema/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+require("reflect-metadata");
+tslib_1.__exportStar(require("./constants.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("./opra-schema.definition.js"), exports);
+tslib_1.__exportStar(require("./decorators/opr-complex-type.decorator.js"), exports);
+tslib_1.__exportStar(require("./decorators/opr-field.decorator.js"), exports);
+tslib_1.__exportStar(require("./decorators/opr-collection-resource.decorator.js"), exports);
+tslib_1.__exportStar(require("./decorators/opr-singleton-resource.decorator.js"), exports);
+tslib_1.__exportStar(require("./decorators/opr-resolver.decorator.js"), exports);
+tslib_1.__exportStar(require("./interfaces/resource-container.interface.js"), exports);
+tslib_1.__exportStar(require("./implementation/document-builder.js"), exports);
+tslib_1.__exportStar(require("./implementation/opra-document.js"), exports);
+tslib_1.__exportStar(require("./implementation/data-type/data-type.js"), exports);
+tslib_1.__exportStar(require("./implementation/data-type/complex-type.js"), exports);
+tslib_1.__exportStar(require("./implementation/data-type/simple-type.js"), exports);
+tslib_1.__exportStar(require("./implementation/data-type/union-type.js"), exports);
+tslib_1.__exportStar(require("./implementation/resource/resource-info.js"), exports);
+tslib_1.__exportStar(require("./implementation/resource/container-resource-info.js"), exports);
+tslib_1.__exportStar(require("./implementation/resource/collection-resource-info.js"), exports);
+tslib_1.__exportStar(require("./implementation/resource/singleton-resource-info.js"), exports);
+tslib_1.__exportStar(require("./implementation/query/index.js"), exports);
+tslib_1.__exportStar(require("./type-helpers/mixin-type.helper.js"), exports);
+tslib_1.__exportStar(require("./type-helpers/extend-type.helper.js"), exports);
+tslib_1.__exportStar(require("./implementation/schema-builder/extract-type-metadata.util.js"), exports);
+tslib_1.__exportStar(require("./implementation/schema-builder/extract-resource-metadata.util.js"), exports);

package/cjs/schema/interfaces/child-field-query.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/schema/interfaces/data-type.metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/schema/interfaces/resource-container.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/schema/interfaces/resource.metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });