@opra/core 0.3.0 → 0.4.0

package/esm/adapter/http-adapter.js

@@ -0,0 +1,238 @@
+import { BadRequestError, InternalServerError, IssueSeverity, MethodNotAllowedError, NotFoundError, OpraException, wrapException } from '@opra/exception';
+import { CollectionCreateQuery, CollectionDeleteManyQuery, CollectionDeleteQuery, CollectionGetQuery, CollectionResourceInfo, CollectionSearchQuery, CollectionUpdateManyQuery, CollectionUpdateQuery, ComplexType, ContainerResourceInfo, FieldGetQuery, OpraSchema, SingletonGetQuery, SingletonResourceInfo, UnionType, } from '@opra/schema';
+import { OpraURL } from '@opra/url';
+import { HttpHeaders, HttpStatus } from '../enums/index.js';
+import { HeadersMap } from '../helpers/headers-map.js';
+import { OpraAdapter } from './adapter.js';
+import { QueryContext } from './query-context.js';
+export class OpraHttpAdapter extends OpraAdapter {
+    prepareRequests(executionContext) {
+        const req = executionContext.getRequestWrapper();
+        // todo implement batch requests
+        if (this.isBatch(executionContext)) {
+            throw new Error('not implemented yet');
+        }
+        const url = new OpraURL(req.getUrl());
+        return [
+            this.prepareRequest(executionContext, url, req.getMethod(), new HeadersMap(req.getHeaders()), req.getBody())
+        ];
+    }
+    prepareRequest(executionContext, url, method, headers, body) {
+        if (!url.path.size)
+            throw new BadRequestError();
+        if (method !== 'GET' && url.path.size > 1)
+            throw new BadRequestError();
+        const query = this.buildQuery(url, method, body);
+        if (!query)
+            throw new MethodNotAllowedError({
+                message: `Method "${method}" is not allowed by target endpoint`
+            });
+        return new QueryContext({
+            service: this.document,
+            executionContext,
+            query,
+            headers: new HeadersMap(),
+            params: url.searchParams,
+            continueOnError: query.operation === 'read'
+        });
+    }
+    buildQuery(url, method, body) {
+        const pathLen = url.path.size;
+        let p = url.path.get(0);
+        let resource = this._internalResources.get(p.resource) || this.document.getResource(p.resource);
+        let container;
+        let pathIndex = 0;
+        while (resource && resource instanceof ContainerResourceInfo) {
+            container = resource;
+            p = url.path.get(++pathIndex);
+            resource = container.getResource(p.resource);
+        }
+        try {
+            method = method.toUpperCase();
+            let query;
+            if (resource instanceof SingletonResourceInfo && !p.key) {
+                switch (method) {
+                    case 'GET': {
+                        query = new SingletonGetQuery(resource);
+                    }
+                }
+            }
+            else if (resource instanceof CollectionResourceInfo) {
+                switch (method) {
+                    case 'GET': {
+                        if (p.key) {
+                            const searchParams = url.searchParams;
+                            query = new CollectionGetQuery(resource, p.key, {
+                                pick: searchParams.get('$pick'),
+                                omit: searchParams.get('$omit'),
+                                include: searchParams.get('$include')
+                            });
+                        }
+                        else {
+                            const searchParams = url.searchParams;
+                            query = new CollectionSearchQuery(resource, {
+                                filter: searchParams.get('$filter'),
+                                limit: searchParams.get('$limit'),
+                                skip: searchParams.get('$skip'),
+                                distinct: searchParams.get('$distinct'),
+                                count: searchParams.get('$count'),
+                                sort: searchParams.get('$sort'),
+                                pick: searchParams.get('$pick'),
+                                omit: searchParams.get('$omit'),
+                                include: searchParams.get('$include')
+                            });
+                        }
+                        break;
+                    }
+                    case 'DELETE': {
+                        const searchParams = url.searchParams;
+                        query = p.key
+                            ? new CollectionDeleteQuery(resource, p.key)
+                            : new CollectionDeleteManyQuery(resource, {
+                                filter: searchParams.get('$filter'),
+                            });
+                        break;
+                    }
+                    case 'POST': {
+                        if (!p.key) {
+                            const searchParams = url.searchParams;
+                            query = new CollectionCreateQuery(resource, body, {
+                                pick: searchParams.get('$pick'),
+                                omit: searchParams.get('$omit'),
+                                include: searchParams.get('$include')
+                            });
+                        }
+                        break;
+                    }
+                    case 'PATCH': {
+                        if (p.key) {
+                            const searchParams = url.searchParams;
+                            query = new CollectionUpdateQuery(resource, p.key, body, {
+                                pick: searchParams.get('$pick'),
+                                omit: searchParams.get('$omit'),
+                                include: searchParams.get('$include')
+                            });
+                        }
+                        else {
+                            const searchParams = url.searchParams;
+                            query = new CollectionUpdateManyQuery(resource, body, {
+                                filter: searchParams.get('$filter')
+                            });
+                        }
+                        break;
+                    }
+                }
+            }
+            else
+                throw new InternalServerError();
+            if (query instanceof SingletonGetQuery || query instanceof CollectionGetQuery || query instanceof FieldGetQuery) {
+                // Move through properties
+                let parentType;
+                const curPath = [];
+                let parent = query;
+                while (++pathIndex < pathLen) {
+                    p = url.path.get(pathIndex);
+                    parentType = parent.dataType;
+                    if (parent.dataType instanceof UnionType) {
+                        if (parent.dataType.name === 'any')
+                            parentType = this.document.getComplexDataType('object');
+                        else
+                            throw new TypeError(`"${resource.name}.${curPath.join()}" is a UnionType and needs type casting.`);
+                    }
+                    if (!(parentType instanceof ComplexType))
+                        throw new TypeError(`"${resource.name}.${curPath.join()}" is not a ComplexType and has no fields.`);
+                    curPath.push(p.resource);
+                    parent.child = new FieldGetQuery(parent, p.resource, { castingType: parentType });
+                    parent = parent.child;
+                }
+            }
+            return query;
+        }
+        catch (e) {
+            if (e instanceof OpraException)
+                throw e;
+            throw new BadRequestError(e);
+        }
+    }
+    async sendResponse(executionContext, queryContexts) {
+        const outputPackets = [];
+        for (const ctx of queryContexts) {
+            const v = this.createOutput(ctx);
+            outputPackets.push(v);
+        }
+        if (this.isBatch(executionContext)) {
+            // this.writeError([], new InternalServerError({message: 'Not implemented yet'}));
+            return;
+        }
+        if (!outputPackets.length)
+            return this.sendError(executionContext, new NotFoundError());
+        const out = outputPackets[0];
+        const resp = executionContext.getResponseWrapper();
+        resp.setStatus(out.status);
+        resp.setHeader(HttpHeaders.Content_Type, 'application/json');
+        resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
+        resp.setHeader(HttpHeaders.Pragma, 'no-cache');
+        resp.setHeader(HttpHeaders.Expires, '-1');
+        resp.setHeader(HttpHeaders.X_Opra_Version, OpraSchema.Version);
+        if (out.headers) {
+            for (const [k, v] of Object.entries(out.headers)) {
+                resp.setHeader(k, v);
+            }
+        }
+        resp.send(JSON.stringify(out.body));
+        resp.end();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    isBatch(executionContext) {
+        return false;
+    }
+    createOutput(ctx) {
+        const { query } = ctx;
+        let body;
+        let status = ctx.status || 0;
+        const errors = ctx.errors.map(e => wrapException(e));
+        if (errors && errors.length) {
+            // Sort errors from fatal to info
+            errors.sort((a, b) => {
+                const i = IssueSeverity.Keys.indexOf(a.issue.severity) - IssueSeverity.Keys.indexOf(b.issue.severity);
+                if (i === 0)
+                    return b.status - a.status;
+                return i;
+            });
+            if (!status || status < HttpStatus.BAD_REQUEST) {
+                status = errors[0].status;
+                if (status < HttpStatus.BAD_REQUEST)
+                    status = HttpStatus.INTERNAL_SERVER_ERROR;
+            }
+            body = {
+                operation: ctx.query.method,
+                errors: errors.map(e => e.issue)
+            };
+        }
+        else {
+            body = ctx.response;
+            status = status || (query.operation === 'create' ? HttpStatus.CREATED : HttpStatus.OK);
+        }
+        body = this.i18n.deep(body);
+        return {
+            status,
+            headers: ctx.responseHeaders.toObject(),
+            body
+        };
+    }
+    async sendError(executionContext, error) {
+        const resp = executionContext.getResponseWrapper();
+        resp.setStatus(error.status || 500);
+        resp.setHeader(HttpHeaders.Content_Type, 'application/json');
+        resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
+        resp.setHeader(HttpHeaders.Pragma, 'no-cache');
+        resp.setHeader(HttpHeaders.Expires, '-1');
+        resp.setHeader(HttpHeaders.X_Opra_Version, OpraSchema.Version);
+        const issue = this.i18n.deep(error.issue);
+        const body = {
+            operation: 'unknown',
+            errors: [issue]
+        };
+        resp.send(JSON.stringify(body));
+    }
+}

package/esm/adapter/metadata-resource.d.ts

@@ -0,0 +1,8 @@
+import { SingletonResourceInfo } from '@opra/schema';
+import { ISingletonResource } from '../interfaces/resource.interface.js';
+import { JsonSingletonService } from '../services/json-singleton-service.js';
+export declare class MetadataResource implements ISingletonResource<any> {
+    service: JsonSingletonService<any>;
+    init(resource: SingletonResourceInfo): void;
+    get(): any;
+}

package/esm/adapter/metadata-resource.js

@@ -0,0 +1,20 @@
+import { __decorate } from "tslib";
+import { OprSingletonResource } from '@opra/schema';
+import { JsonSingletonService } from '../services/json-singleton-service.js';
+let MetadataResource = class MetadataResource {
+    service;
+    init(resource) {
+        this.service = new JsonSingletonService(resource.dataType, {
+            data: resource.document.getMetadata(true)
+        });
+    }
+    get() {
+        return this.service.get();
+    }
+};
+MetadataResource = __decorate([
+    OprSingletonResource(Object, {
+        name: '$metadata'
+    })
+], MetadataResource);
+export { MetadataResource };

package/esm/{implementation → adapter}/query-context.d.ts

@@ -1,15 +1,15 @@
 import { OpraException } from '@opra/exception';
-import { OpraAnyQuery, OpraApi } from '@opra/schema';
-import { SearchParams } from '@opra/url';
+import { OpraDocument, OpraQuery } from '@opra/schema';
+import { OpraURLSearchParams } from '@opra/url';
 import { HttpStatus } from '../enums/index.js';
+import { HeadersMap } from '../helpers/headers-map.js';
 import { ContextType, IExecutionContext, IHttpExecutionContext } from '../interfaces/execution-context.interface.js';
-import { HeadersMap } from './headers-map.js';
 export declare type QueryContextArgs = Pick<QueryContext, 'service' | 'executionContext' | 'query' | 'params' | 'headers' | 'userContext' | 'parentValue' | 'continueOnError'>;
 export declare class QueryContext {
-    readonly service: OpraApi;
+    readonly service: OpraDocument;
     readonly executionContext: IExecutionContext;
-    readonly query: OpraAnyQuery;
-    readonly params: SearchParams;
+    readonly query: OpraQuery;
+    readonly params: OpraURLSearchParams;
     readonly headers: HeadersMap;
     readonly parentValue?: any;
     readonly resultPath: string;

package/esm/{implementation → adapter}/query-context.js

@@ -1,5 +1,5 @@
 import { OpraURLSearchParams } from '@opra/url';
-import { HeadersMap } from './headers-map.js';
+import { HeadersMap } from '../helpers/headers-map.js';
 export class QueryContext {
     service;
     executionContext;

package/esm/enums/http-headers.enum.d.ts

@@ -3,7 +3,7 @@
  */
 export declare enum HttpHeaders {
     X_Opra_Version = "X-Opra-Version",
-    X_Opra_Schema = "X-Opra-Schema",
+    X_Opra_DataType = "X-Opra-DataType",
     X_Opra_Count = "X-Opra-Count",
     /**
      * Defines the authentication method that should be used to access a resource.

package/esm/enums/http-headers.enum.js

@@ -6,7 +6,7 @@ export var HttpHeaders;
 (function (HttpHeaders) {
     /* *** Custom Headers *** */
     HttpHeaders["X_Opra_Version"] = "X-Opra-Version";
-    HttpHeaders["X_Opra_Schema"] = "X-Opra-Schema";
+    HttpHeaders["X_Opra_DataType"] = "X-Opra-DataType";
     HttpHeaders["X_Opra_Count"] = "X-Opra-Count";
     /* *** Authentication *** */
     /**

package/esm/{implementation → helpers}/headers-map.d.ts

@@ -1,4 +1,4 @@
-import { ResponsiveMap } from '@opra/schema';
+import { ResponsiveMap } from '@opra/common';
 export declare class HeadersMap extends ResponsiveMap<string, string> {
     constructor(data?: any);
     toObject(): Record<string, string>;

package/esm/{implementation → helpers}/headers-map.js

@@ -1,4 +1,4 @@
-import { ResponsiveMap } from '@opra/schema';
+import { ResponsiveMap } from '@opra/common';
 import { HttpHeaders } from '../enums/index.js';
 export class HeadersMap extends ResponsiveMap {
     constructor(data) {

package/esm/index.d.ts

@@ -2,10 +2,11 @@ import "reflect-metadata";
 export * from './types.js';
 export * from './enums/index.js';
 export * from './interfaces/execution-context.interface.js';
-export * from './interfaces/entity-service.interface.js';
-export * from './implementation/query-context.js';
-export * from './implementation/adapter.js';
-export * from './implementation/http-adapter.js';
-export * from './implementation/express-adapter.js';
+export * from './interfaces/resource.interface.js';
+export * from './adapter/query-context.js';
+export * from './adapter/adapter.js';
+export * from './adapter/http-adapter.js';
+export * from './adapter/express-adapter.js';
 export * from './services/data-service.js';
 export * from './services/json-collection-service.js';
+export * from './services/json-singleton-service.js';

package/esm/index.js

@@ -2,10 +2,11 @@ import "reflect-metadata";
 export * from './types.js';
 export * from './enums/index.js';
 export * from './interfaces/execution-context.interface.js';
-export * from './interfaces/entity-service.interface.js';
-export * from './implementation/query-context.js';
-export * from './implementation/adapter.js';
-export * from './implementation/http-adapter.js';
-export * from './implementation/express-adapter.js';
+export * from './interfaces/resource.interface.js';
+export * from './adapter/query-context.js';
+export * from './adapter/adapter.js';
+export * from './adapter/http-adapter.js';
+export * from './adapter/express-adapter.js';
 export * from './services/data-service.js';
 export * from './services/json-collection-service.js';
+export * from './services/json-singleton-service.js';

package/esm/interfaces/resource.interface.d.ts

@@ -0,0 +1,22 @@
+import { Maybe } from 'ts-gems';
+import { ResourceInfo } from '@opra/schema';
+import { PartialOutput } from '../types.js';
+export interface IResource {
+    init?(resource: ResourceInfo): void | Promise<void>;
+}
+export interface ICollectionResource<T, TOutput = PartialOutput<T>> extends IResource {
+    create?(...args: any[]): TOutput | Promise<TOutput>;
+    count?(...args: any[]): number | Promise<number>;
+    delete?(...args: any[]): boolean | Promise<boolean>;
+    deleteMany?(...args: any[]): number | Promise<number>;
+    get?(...args: any[]): Maybe<TOutput> | Promise<Maybe<TOutput>>;
+    search?(...args: any[]): TOutput[] | Promise<TOutput[]>;
+    update?(...args: any[]): Maybe<TOutput> | Promise<Maybe<TOutput>>;
+    updateMany?(...args: any[]): number | Promise<number>;
+}
+export interface ISingletonResource<T, TOutput = PartialOutput<T>> extends IResource {
+    create?(...args: any[]): TOutput | Promise<TOutput>;
+    delete?(...args: any[]): boolean | Promise<boolean>;
+    get?(...args: any[]): Maybe<TOutput> | Promise<Maybe<TOutput>>;
+    update?(...args: any[]): Maybe<TOutput> | Promise<Maybe<TOutput>>;
+}

package/esm/interfaces/resource.interface.js

@@ -0,0 +1 @@
+export {};

package/esm/services/json-collection-service.d.ts

@@ -1,22 +1,21 @@
 import { Maybe } from 'ts-gems';
-import { ComplexType, EntityResource, OpraAnyQuery, OpraSchema } from '@opra/schema';
+import { CollectionResourceInfo, ComplexType, OpraQuery, OpraSchema } from '@opra/schema';
 import { Expression } from '@opra/url';
-import { QueryContext } from '../implementation/query-context.js';
-import { IEntityService } from '../interfaces/entity-service.interface.js';
-import { EntityInput, EntityOutput } from '../types.js';
+import { QueryContext } from '../adapter/query-context.js';
+import { PartialInput, PartialOutput } from '../types.js';
 export interface JsonCollectionServiceOptions {
     resourceName?: string;
     defaultLimit?: number;
     data?: any[];
 }
-export declare class JsonCollectionService<T, TOutput = EntityOutput<T>> implements IEntityService {
-    readonly resource: EntityResource;
+export declare class JsonCollectionService<T, TOutput = PartialOutput<T>> {
+    readonly resource: CollectionResourceInfo;
     private _status;
     private _initError;
     private _dbName;
     private _initData?;
     defaultLimit: number;
-    constructor(resource: EntityResource, options?: JsonCollectionServiceOptions);
+    constructor(resource: CollectionResourceInfo, options?: JsonCollectionServiceOptions);
     get dataType(): ComplexType;
     get primaryKey(): string;
     get resourceName(): string;
@@ -25,15 +24,15 @@ export declare class JsonCollectionService<T, TOutput = EntityOutput<T>> impleme
     get(keyValue: any, options?: JsonCollectionService.GetOptions): Promise<Maybe<TOutput>>;
     count(options?: JsonCollectionService.SearchOptions): Promise<number>;
     search(options?: JsonCollectionService.SearchOptions): Promise<TOutput[]>;
-    create(data: EntityInput<T>, options?: JsonCollectionService.CreateOptions): Promise<TOutput>;
-    update(keyValue: any, data: EntityInput<T>, options?: JsonCollectionService.UpdateOptions): Promise<Maybe<TOutput>>;
-    updateMany(data: EntityInput<T>, options?: JsonCollectionService.UpdateManyOptions): Promise<number>;
+    create(data: PartialInput<T>, options?: JsonCollectionService.CreateOptions): Promise<TOutput>;
+    update(keyValue: any, data: PartialInput<T>, options?: JsonCollectionService.UpdateOptions): Promise<Maybe<TOutput>>;
+    updateMany(data: PartialInput<T>, options?: JsonCollectionService.UpdateManyOptions): Promise<number>;
     delete(keyValue: any): Promise<boolean>;
     deleteMany(options?: JsonCollectionService.DeleteManyOptions): Promise<number>;
     private _waitInitializing;
     protected _init(): Promise<void>;
-    protected _prepare(query: OpraAnyQuery): {
-        method: OpraSchema.EntityMethod;
+    protected _prepare(query: OpraQuery): {
+        method: OpraSchema.CollectionMethod;
         options: any;
         keyValue?: any;
         values?: any;

package/esm/services/json-collection-service.js

@@ -2,7 +2,7 @@ import _ from 'lodash';
 import merge from 'putil-merge';
 import { nSQL } from "@nano-sql/core";
 import { BadRequestError, MethodNotAllowedError, ResourceConflictError } from '@opra/exception';
-import { ComplexType, EntityResource } from '@opra/schema';
+import { CollectionResourceInfo, ComplexType } from '@opra/schema';
 import { $parse, ArrayExpression, BooleanLiteral, ComparisonExpression, DateLiteral, Expression, LogicalExpression, NullLiteral, NumberLiteral, ParenthesesExpression, QualifiedIdentifier, StringLiteral, TimeLiteral } from '@opra/url';
 import { pathToTree } from '../utils/path-to-tree.js';
 let dbId = 1;
@@ -191,7 +191,7 @@ export class JsonCollectionService {
                 indexes: {}
             };
             for (const [k, f] of this.resource.dataType.fields.entries()) {
-                const fieldType = this.resource.owner.getDataType(f.type || 'string');
+                const fieldType = this.resource.document.getDataType(f.type || 'string');
                 const o = table.model[k + ':' + dataTypeToSQLType(fieldType, !!f.isArray)] = {};
                 if (k === this.primaryKey)
                     o.pk = true;
@@ -199,21 +199,21 @@ export class JsonCollectionService {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const indexes = table.indexes;
             // Add indexes for sort fields
-            const searchMethod = this.resource.metadata.methods.search;
-            if (searchMethod) {
-                if (searchMethod.sortFields) {
-                    searchMethod.sortFields.forEach(fieldName => {
+            const searchResolver = this.resource.metadata.search;
+            if (searchResolver) {
+                if (searchResolver.sortFields) {
+                    searchResolver.sortFields.forEach(fieldName => {
                         const f = this.dataType.getField(fieldName);
-                        const fieldType = this.resource.owner.getDataType(f.type || 'string');
+                        const fieldType = this.resource.document.getDataType(f.type || 'string');
                         const t = dataTypeToSQLType(fieldType, !!f.isArray);
                         if (indexingTypes.includes(t))
                             indexes[fieldName + ':' + t] = {};
                     });
                 }
-                if (searchMethod.filters) {
-                    searchMethod.filters.forEach(filter => {
+                if (searchResolver.filters) {
+                    searchResolver.filters.forEach(filter => {
                         const f = this.dataType.getField(filter.field);
-                        const fieldType = this.resource.owner.getDataType(f.type || 'string');
+                        const fieldType = this.resource.document.getDataType(f.type || 'string');
                         const t = dataTypeToSQLType(fieldType, !!f.isArray);
                         if (indexingTypes.includes(t))
                             indexes[filter.field + ':' + t] = {};
@@ -241,10 +241,10 @@ export class JsonCollectionService {
         }
     }
     _prepare(query) {
-        if (query.resource instanceof EntityResource) {
+        if (query.resource instanceof CollectionResourceInfo) {
             if (query.dataType !== this.dataType)
                 throw new TypeError(`Query data type (${query.dataType.name}) ` +
-                    `differs from JsonDataService data type (${this.dataType.name})`);
+                    `differs from JsonCollectionService data type (${this.dataType.name})`);
         }
         switch (query.method) {
             case 'count': {
@@ -272,7 +272,7 @@ export class JsonCollectionService {
                 };
             }
             case 'get': {
-                if (query.kind === 'GetInstanceQuery') {
+                if (query.kind === 'CollectionGetQuery') {
                     const options = _.omitBy({
                         pick: query.pick,
                         omit: query.omit,
@@ -286,7 +286,7 @@ export class JsonCollectionService {
                         args: [keyValue, options]
                     };
                 }
-                if (query.kind === 'GetFieldQuery') {
+                if (query.kind === 'FieldGetQuery') {
                     // todo
                 }
                 break;
@@ -365,7 +365,7 @@ export class JsonCollectionService {
     }
     _convertSelect(args) {
         const result = [];
-        const document = this.dataType.owner;
+        const document = this.dataType.document;
         const processDataType = (dt, path, pick, omit, include) => {
             let kl;
             for (const [k, f] of dt.fields) {

package/esm/services/json-singleton-service.d.ts

@@ -0,0 +1,39 @@
+import { DataType, OpraQuery, OpraSchema } from '@opra/schema';
+import { QueryContext } from '../adapter/query-context.js';
+import { PartialOutput } from '../types.js';
+export interface JsonSingletonServiceOptions<T> {
+    data: T;
+    resourceName?: string;
+}
+export declare class JsonSingletonService<T, TOutput = PartialOutput<T>> {
+    readonly dataType: DataType;
+    protected _data?: T;
+    constructor(dataType: DataType, options?: JsonSingletonServiceOptions<T>);
+    processRequest(ctx: QueryContext): Promise<any>;
+    get(options?: JsonSingletonService.GetOptions): TOutput | undefined;
+    protected _prepare(query: OpraQuery): {
+        method: OpraSchema.SingletonMethod;
+        options: any;
+        keyValue?: any;
+        values?: any;
+        args: any[];
+    };
+}
+export declare namespace JsonSingletonService {
+    type CreateOptions = {
+        query?: string;
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    };
+    type GetOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    };
+    type UpdateOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    };
+}