@opra/common 0.5.0 → 0.6.0

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;

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;