@opra/common 0.4.0 → 0.6.0

package/cjs/schema/implementation/data-type/builtin-data-types.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.primitiveClasses = exports.builtInTypes = void 0;
+const responsive_map_js_1 = require("../../../helpers/responsive-map.js");
+const any_type_js_1 = require("./builtin/any.type.js");
+const base64_binary_type_js_1 = require("./builtin/base64-binary.type.js");
+const bigint_type_js_1 = require("./builtin/bigint.type.js");
+const boolean_type_js_1 = require("./builtin/boolean.type.js");
+const date_type_js_1 = require("./builtin/date.type.js");
+const date_string_type_js_1 = require("./builtin/date-string.type.js");
+const guid_type_js_1 = require("./builtin/guid.type.js");
+const integer_type_js_1 = require("./builtin/integer.type.js");
+const number_type_js_1 = require("./builtin/number.type.js");
+const object_type_js_1 = require("./builtin/object.type.js");
+const string_type_js_1 = require("./builtin/string.type.js");
+const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
+const BufferConstructor = Object.getPrototypeOf(Buffer.from('')).constructor;
+exports.builtInTypes = new responsive_map_js_1.ResponsiveMap();
+exports.builtInTypes.set('any', any_type_js_1.AnyType);
+exports.builtInTypes.set('base64Binary', base64_binary_type_js_1.Base64BinaryType);
+exports.builtInTypes.set('bigint', bigint_type_js_1.BigIntType);
+exports.builtInTypes.set('boolean', boolean_type_js_1.BooleanType);
+exports.builtInTypes.set('date', date_type_js_1.DateType);
+exports.builtInTypes.set('dateString', date_string_type_js_1.DateStringType);
+exports.builtInTypes.set('guid', guid_type_js_1.GuidType);
+exports.builtInTypes.set('integer', integer_type_js_1.IntegerType);
+exports.builtInTypes.set('number', number_type_js_1.NumberType);
+exports.builtInTypes.set('object', object_type_js_1.ObjectType);
+exports.builtInTypes.set('string', string_type_js_1.StringType);
+exports.primitiveClasses = new Map();
+exports.primitiveClasses.set(Boolean, 'boolean');
+exports.primitiveClasses.set(String, 'string');
+exports.primitiveClasses.set(Number, 'number');
+exports.primitiveClasses.set(Date, 'date');
+exports.primitiveClasses.set(BigIntConstructor, 'bigint');
+exports.primitiveClasses.set(BufferConstructor, 'base64Binary');
+exports.primitiveClasses.set(Object, 'object');

package/cjs/schema/implementation/data-type/complex-type.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComplexType = void 0;
+const responsive_map_js_1 = require("../../../helpers/responsive-map.js");
+const clone_object_util_js_1 = require("../../utils/clone-object.util.js");
+const inspect_util_js_1 = require("../../utils/inspect.util.js");
+const data_type_js_1 = require("./data-type.js");
+class ComplexType extends data_type_js_1.DataType {
+    _initialized = false;
+    _mixinAdditionalFields;
+    ownFields = new responsive_map_js_1.ResponsiveMap();
+    fields = new responsive_map_js_1.ResponsiveMap();
+    constructor(owner, name, args) {
+        super(owner, name, {
+            kind: 'ComplexType',
+            ...args
+        });
+    }
+    get abstract() {
+        return !!this._metadata.abstract;
+    }
+    get additionalFields() {
+        return this._metadata.additionalFields || this._mixinAdditionalFields;
+    }
+    get extends() {
+        return this._metadata.extends;
+    }
+    getField(fieldName) {
+        if (fieldName.includes('.')) {
+            let dt = this;
+            const arr = fieldName.split('.');
+            let field;
+            for (const a of arr) {
+                field = dt.getField(a);
+                dt = dt.document.getDataType(field.type || 'string');
+            }
+            // @ts-ignore
+            return field;
+        }
+        const t = this.fields.get(fieldName);
+        if (!t)
+            throw new Error(`"${this.name}" type doesn't have a field named "${fieldName}"`);
+        return t;
+    }
+    getFieldType(fieldName) {
+        const field = this.getField(fieldName);
+        return this.document.getDataType(field.type || 'string');
+    }
+    getOwnField(name) {
+        const t = this.ownFields.get(name);
+        if (!t)
+            throw new Error(`"${this.name}" type doesn't have an own field named "${name}"`);
+        return t;
+    }
+    getSchema() {
+        const out = super.getSchema();
+        if (this.additionalFields)
+            out.additionalFields = this.additionalFields;
+        if (this.ownFields.size) {
+            out.fields = {};
+            for (const [k, prop] of this.ownFields) {
+                out.fields[k] = (0, clone_object_util_js_1.cloneObject)(prop);
+                delete out.fields[k].name;
+            }
+        }
+        return out;
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    [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}]`;
+    }
+    init() {
+        if (this._initialized)
+            return;
+        this._initialized = true;
+        const metadata = this._metadata;
+        if (metadata.extends) {
+            for (const ext of metadata.extends) {
+                const baseType = this.document.types.get(ext.type);
+                if (!baseType)
+                    throw new TypeError(`Extending schema (${ext.type}) of data type "${this.name}" does not exists`);
+                if (!(baseType instanceof ComplexType))
+                    throw new TypeError(`Cannot extend ${this.name} from a "${baseType.kind}"`);
+                baseType.init();
+                if (baseType.additionalFields)
+                    this._mixinAdditionalFields = true;
+                for (const [k, prop] of baseType.fields) {
+                    const f = (0, clone_object_util_js_1.cloneObject)(prop);
+                    f.name = k;
+                    f.parent = this;
+                    this.fields.set(k, f);
+                }
+            }
+        }
+        if (metadata.fields) {
+            for (const [k, prop] of Object.entries(metadata.fields)) {
+                const t = this.document.types.get(prop.type);
+                if (!t)
+                    throw new TypeError(`Type "${prop.type}" defined for "${this.name}.${k}" does not exists`);
+                const f = (0, clone_object_util_js_1.cloneObject)(prop);
+                f.name = k;
+                this.fields.set(k, f);
+                this.ownFields.set(k, f);
+            }
+        }
+    }
+}
+exports.ComplexType = ComplexType;

package/cjs/schema/implementation/data-type/data-type.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataType = void 0;
+const clone_object_util_js_1 = require("../../utils/clone-object.util.js");
+class DataType {
+    _document;
+    _metadata;
+    _name;
+    constructor(document, name, metadata) {
+        this._document = document;
+        this._name = name;
+        this._metadata = metadata;
+    }
+    get document() {
+        return this._document;
+    }
+    get kind() {
+        return this._metadata.kind;
+    }
+    get name() {
+        return this._name;
+    }
+    get description() {
+        return this._metadata.description;
+    }
+    get ctor() {
+        return this._metadata.ctor;
+    }
+    parse(value) {
+        return this._metadata.parse ? this._metadata.parse(value) : value;
+    }
+    getSchema(jsonOnly) {
+        return (0, clone_object_util_js_1.cloneObject)(this._metadata, jsonOnly);
+    }
+}
+exports.DataType = DataType;

package/cjs/schema/implementation/data-type/simple-type.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleType = void 0;
+const inspect_util_js_1 = require("../../utils/inspect.util.js");
+const data_type_js_1 = require("./data-type.js");
+class SimpleType extends data_type_js_1.DataType {
+    constructor(owner, name, args) {
+        super(owner, name, {
+            kind: 'SimpleType',
+            ...args
+        });
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    [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.SimpleType = SimpleType;

package/cjs/schema/implementation/data-type/union-type.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionType = void 0;
+const lodash_1 = require("lodash");
+const inspect_util_js_1 = require("../../utils/inspect.util.js");
+const complex_type_js_1 = require("./complex-type.js");
+const data_type_js_1 = require("./data-type.js");
+class UnionType extends data_type_js_1.DataType {
+    types;
+    hasAdditionalFields;
+    constructor(owner, name, args) {
+        super(owner, name, (0, lodash_1.omit)({ kind: 'UnionType', ...args }, ['types']));
+        this.types = args.types;
+        this.hasAdditionalFields = name === 'any' ||
+            !!this.types.find(t => t instanceof complex_type_js_1.ComplexType && t.additionalFields);
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    [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.UnionType = UnionType;

package/cjs/schema/implementation/document-builder.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentBuilder = void 0;
+const tslib_1 = require("tslib");
+const putil_promisify_1 = require("putil-promisify");
+const Optionals = tslib_1.__importStar(require("@opra/optionals"));
+const responsive_map_js_1 = require("../../helpers/responsive-map.js");
+const opra_schema_definition_js_1 = require("../opra-schema.definition.js");
+const class_utils_js_1 = require("../utils/class.utils.js");
+const builtin_data_types_js_1 = require("./data-type/builtin-data-types.js");
+const extract_resource_metadata_util_js_1 = require("./schema-builder/extract-resource-metadata.util.js");
+const extract_type_metadata_util_js_1 = require("./schema-builder/extract-type-metadata.util.js");
+class DocumentBuilder {
+    _args;
+    _dataTypes = new responsive_map_js_1.ResponsiveMap();
+    _resources = new responsive_map_js_1.ResponsiveMap();
+    constructor(args) {
+        this._args = args;
+    }
+    buildSchema() {
+        const out = {
+            ...this._args,
+            version: opra_schema_definition_js_1.OpraSchema.Version,
+        };
+        if (this._dataTypes.size)
+            out.types = Array.from(this._dataTypes.keys()).sort()
+                .reduce((target, name) => {
+                target[name] = this._dataTypes.get(name);
+                return target;
+            }, {});
+        if (this._resources.size)
+            out.resources = Array.from(this._resources.keys()).sort()
+                .reduce((target, name) => {
+                target[name] = this._resources.get(name);
+                return target;
+            }, {});
+        return out;
+    }
+    async addDataTypeSchema(name, schema) {
+        if (!opra_schema_definition_js_1.OpraSchema.isDataType(schema))
+            throw new TypeError(`Invalid DataType schema`);
+        const currentSchema = this._dataTypes.get(name);
+        if (currentSchema) {
+            if (!(currentSchema.kind === schema.kind && currentSchema.ctor && currentSchema.ctor === schema.ctor))
+                throw new Error(`An other instance of "${name}" data type previously defined`);
+            return;
+        }
+        this._dataTypes.set(name, schema);
+        if (opra_schema_definition_js_1.OpraSchema.isComplexType(schema)) {
+            if (schema.extends) {
+                for (const imp of schema.extends) {
+                    // noinspection SuspiciousTypeOfGuard
+                    if (typeof imp.type !== 'string') {
+                        imp.type = await this.addDataTypeClass(imp.type);
+                    }
+                }
+            }
+            if (schema.fields) {
+                for (const field of Object.values(schema.fields)) {
+                    field.type = field.type || 'string';
+                    // noinspection SuspiciousTypeOfGuard
+                    if (typeof field.type !== 'string') {
+                        field.type = await this.addDataTypeClass(field.type);
+                    }
+                }
+            }
+        }
+    }
+    async addDataTypeClass(thunk) {
+        thunk = (0, putil_promisify_1.isPromise)(thunk) ? await thunk : thunk;
+        if (!(0, class_utils_js_1.isConstructor)(thunk))
+            return this.addDataTypeClass(thunk());
+        const internalTypeName = builtin_data_types_js_1.primitiveClasses.get(thunk);
+        if (internalTypeName)
+            return internalTypeName;
+        const namedSchema = await (0, extract_type_metadata_util_js_1.extractDataTypeSchema)(thunk);
+        const name = namedSchema.name;
+        const schema = namedSchema;
+        delete schema.name;
+        await this.addDataTypeSchema(name, schema);
+        return name;
+    }
+    async addResourceSchema(name, schema) {
+        if (!opra_schema_definition_js_1.OpraSchema.isResource(schema))
+            throw new TypeError(`Invalid Resource schema`);
+        if (this._resources.has(name))
+            throw new Error(`An other instance of "${name}" resource previously defined`);
+        if (opra_schema_definition_js_1.OpraSchema.isCollectionResource(schema) || opra_schema_definition_js_1.OpraSchema.isSingletonResource(schema)) {
+            const type = typeof schema.type === 'function'
+                ? await this.addDataTypeClass(schema.type)
+                : schema.type;
+            schema.type = type;
+            if (!(this._dataTypes.has(schema.type) || builtin_data_types_js_1.builtInTypes.has(schema.type)))
+                throw new Error(`Resource registration error. Type "${schema.type}" not found.`);
+        }
+        if (opra_schema_definition_js_1.OpraSchema.isCollectionResource(schema)) {
+            // Determine keyFields if not set
+            if (!schema.keyFields) {
+                const dataType = this._dataTypes.get(schema.type);
+                if (Optionals.SqbConnect && dataType?.ctor) {
+                    const sqbEntity = Optionals.SqbConnect.EntityMetadata.get(dataType?.ctor);
+                    if (sqbEntity?.indexes) {
+                        const primaryIndex = sqbEntity.indexes.find(x => x.primary);
+                        if (primaryIndex) {
+                            schema.keyFields = primaryIndex.columns;
+                        }
+                    }
+                }
+                schema.keyFields = Array.isArray(schema.keyFields)
+                    ? (schema.keyFields.length ? schema.keyFields : '')
+                    : schema.keyFields;
+                if (!schema.keyFields)
+                    throw new TypeError(`You must provide keyFields for "${name}" entity resource`);
+            }
+        }
+        this._resources.set(name, schema);
+    }
+    async addResourceInstance(thunk) {
+        thunk = (0, putil_promisify_1.isPromise)(thunk) ? await thunk : thunk;
+        let instance;
+        if (typeof thunk === 'function') {
+            if ((0, class_utils_js_1.isConstructor)(thunk)) {
+                instance = {};
+                Object.setPrototypeOf(instance, thunk.prototype);
+            }
+            else {
+                instance = await thunk();
+            }
+        }
+        else
+            instance = thunk;
+        const namedSchema = await (0, extract_resource_metadata_util_js_1.extractResourceSchema)(instance);
+        const name = namedSchema.name;
+        const schema = namedSchema;
+        delete schema.name;
+        await this.addResourceSchema(name, schema);
+        return name;
+    }
+}
+exports.DocumentBuilder = DocumentBuilder;

package/cjs/schema/implementation/opra-document.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraDocument = void 0;
+const lodash_1 = require("lodash");
+const responsive_map_js_1 = require("../../helpers/responsive-map.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 string_compare_util_js_1 = require("../utils/string-compare.util.js");
+const builtin_data_types_js_1 = require("./data-type/builtin-data-types.js");
+const complex_type_js_1 = require("./data-type/complex-type.js");
+const simple_type_js_1 = require("./data-type/simple-type.js");
+const union_type_js_1 = require("./data-type/union-type.js");
+const document_builder_js_1 = require("./document-builder.js");
+const collection_resource_info_js_1 = require("./resource/collection-resource-info.js");
+const singleton_resource_info_js_1 = require("./resource/singleton-resource-info.js");
+class OpraDocument {
+    _ownTypes = new responsive_map_js_1.ResponsiveMap();
+    _types = new responsive_map_js_1.ResponsiveMap();
+    _resources = new responsive_map_js_1.ResponsiveMap();
+    constructor(schema) {
+        this._meta = (0, lodash_1.omit)(schema, ['types', 'resources']);
+        for (const [name, t] of builtin_data_types_js_1.builtInTypes.entries()) {
+            this._addDataType(name, t, false);
+        }
+        if (schema.types)
+            for (const [name, t] of Object.entries(schema.types)) {
+                this._addDataType(name, t, true);
+            }
+        this._initTypes();
+        if (schema.resources)
+            for (const [name, t] of Object.entries(schema.resources)) {
+                this._addResource(name, t);
+            }
+    }
+    get info() {
+        return this._meta.info;
+    }
+    get types() {
+        return this._types;
+    }
+    getDataType(name) {
+        const t = this.types.get(name);
+        if (t)
+            return t;
+        throw new Error(`Data type "${name}" does not exists`);
+    }
+    getComplexDataType(name) {
+        const t = this.getDataType(name);
+        if (t && t instanceof complex_type_js_1.ComplexType)
+            return t;
+        throw new Error(`Data type "${name}" is not a ComplexType`);
+    }
+    getSimpleDataType(name) {
+        const t = this.getDataType(name);
+        if (t && t instanceof simple_type_js_1.SimpleType)
+            return t;
+        throw new Error(`Data type "${name}" is not a SimpleType`);
+    }
+    getUnionDataType(name) {
+        const t = this.getDataType(name);
+        if (t && t instanceof union_type_js_1.UnionType)
+            return t;
+        throw new Error(`Data type "${name}" is not a UnionType`);
+    }
+    get resources() {
+        return this._resources;
+    }
+    get servers() {
+        return this._meta.servers;
+    }
+    getResource(name) {
+        const t = this.resources.get(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 CollectionResource`);
+        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;
+    }
+    getMetadata(jsonOnly) {
+        const out = {
+            version: opra_schema_definition_js_1.OpraSchema.Version,
+            info: (0, clone_object_util_js_1.cloneObject)(this.info),
+        };
+        if (this._ownTypes.size) {
+            out.types = Array.from(this._ownTypes.values())
+                .sort((a, b) => (0, string_compare_util_js_1.stringCompare)(a.name, b.name))
+                .reduce((target, t) => {
+                target[t.name] = t.getSchema(jsonOnly);
+                return target;
+            }, {});
+        }
+        if (this.resources.size) {
+            out.resources = Array.from(this._resources.values())
+                .sort((a, b) => (0, string_compare_util_js_1.stringCompare)(a.name, b.name))
+                .reduce((target, t) => {
+                target[t.name] = t.getSchema(jsonOnly);
+                return target;
+            }, {});
+        }
+        return out;
+    }
+    _addDataType(name, schema, isOwn) {
+        let dataType = this._types.get(name);
+        if (dataType)
+            return dataType;
+        if (opra_schema_definition_js_1.OpraSchema.isComplexType(schema)) {
+            dataType = new complex_type_js_1.ComplexType(this, name, schema);
+        }
+        else if (opra_schema_definition_js_1.OpraSchema.isSimpleType(schema)) {
+            dataType = new simple_type_js_1.SimpleType(this, name, schema);
+        }
+        else if (opra_schema_definition_js_1.OpraSchema.isUnionTypee(schema)) {
+            // todo build types array
+            dataType = new union_type_js_1.UnionType(this, name, { ...schema, types: [] });
+        }
+        else
+            throw new TypeError(`Invalid data type schema`);
+        this._types.set(name, dataType);
+        if (isOwn)
+            this._ownTypes.set(name, dataType);
+        return dataType;
+    }
+    _addResource(name, schema) {
+        if (opra_schema_definition_js_1.OpraSchema.isCollectionResource(schema) || opra_schema_definition_js_1.OpraSchema.isSingletonResource(schema)) {
+            const dataType = this.getDataType(schema.type);
+            if (!dataType)
+                throw new TypeError(`Datatype "${schema.type}" declared in CollectionResource (${name}) does not exists`);
+            if (!(dataType instanceof complex_type_js_1.ComplexType))
+                throw new TypeError(`${schema.type} is not an ComplexType`);
+            if (opra_schema_definition_js_1.OpraSchema.isCollectionResource(schema))
+                this.resources.set(name, new collection_resource_info_js_1.CollectionResourceInfo(this, name, dataType, schema));
+            else
+                this.resources.set(name, new singleton_resource_info_js_1.SingletonResourceInfo(this, name, dataType, schema));
+        }
+        else
+            throw new TypeError(`Unknown resource kind (${schema.kind})`);
+    }
+    _initTypes() {
+        for (const dataType of this._types.values()) {
+            if (dataType instanceof complex_type_js_1.ComplexType) {
+                dataType.init();
+            }
+        }
+    }
+    static async create(args) {
+        const builder = new document_builder_js_1.DocumentBuilder(args);
+        if (args.types) {
+            if (Array.isArray(args.types)) {
+                for (const t of args.types)
+                    await builder.addDataTypeClass(t);
+            }
+            else
+                for (const [k, v] of Object.entries(args.types)) {
+                    await builder.addDataTypeSchema(k, v);
+                }
+        }
+        if (args.resources) {
+            if (Array.isArray(args.resources)) {
+                for (const t of args.resources)
+                    await builder.addResourceInstance(t);
+            }
+            else
+                for (const [k, v] of Object.entries(args.resources)) {
+                    await builder.addResourceSchema(k, v);
+                }
+        }
+        const schema = builder.buildSchema();
+        return new OpraDocument(schema);
+    }
+}
+exports.OpraDocument = OpraDocument;

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

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

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionCreateQuery = void 0;
+const normalize_field_array_util_js_1 = require("../../utils/normalize-field-array.util.js");
+class CollectionCreateQuery {
+    resource;
+    data;
+    kind = 'CollectionCreateQuery';
+    method = 'create';
+    operation = 'create';
+    pick;
+    omit;
+    include;
+    constructor(resource, data, options) {
+        this.resource = resource;
+        this.data = data;
+        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.CollectionCreateQuery = CollectionCreateQuery;

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionDeleteQuery = void 0;
+class CollectionDeleteQuery {
+    resource;
+    kind = 'CollectionDeleteQuery';
+    method = 'delete';
+    operation = 'delete';
+    keyValue;
+    constructor(resource, keyValue) {
+        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);
+    }
+    get dataType() {
+        return this.resource.dataType;
+    }
+}
+exports.CollectionDeleteQuery = CollectionDeleteQuery;