@opra/elastic 0.33.13 → 1.0.0-alpha.18

package/esm/adapter-utils/prepare-projection.js

@@ -0,0 +1,109 @@
+"use strict";
+// import { ApiField, ComplexType, FieldsProjection, omitNullish, parseFieldsProjection } from '@opra/common';
+// import mongodb, { Document } from 'mongodb';
+//
+// export default function prepareProjection(
+//   dataType: ComplexType,
+//   projection?: string | string[] | Document,
+// ): mongodb.Document | undefined {
+//   if (projection && typeof projection === 'object' && !Array.isArray(projection)) return projection;
+//   const out: Record<string, boolean> = {};
+//   const projection_ =
+//     typeof projection === 'string' || Array.isArray(projection) ? parseFieldsProjection(projection) : projection;
+//   // const exclusionProjection = !pick && !!omit;
+//   prepare(dataType, out, projection_);
+//   return Object.keys(out).length ? out : undefined;
+// }
+//
+// export function prepare(dataType: ComplexType, target: mongodb.Document, projection?: FieldsProjection) {
+//   const defaultFields = !projection || !Object.values(projection).find(p => !p.sign);
+//   const projectionKeys = projection && Object.keys(projection).map(x => x.toLowerCase());
+//   const projectionKeysSet = new Set(projectionKeys);
+//   let fieldName: string;
+//   let field: ApiField;
+//   let k: string;
+//   /** Add fields from data type */
+//   for (field of dataType.fields.values()) {
+//     fieldName = field.name;
+//     k = fieldName.toLowerCase();
+//     projectionKeysSet.delete(k);
+//     const p = projection?.[k];
+//     if (
+//       /** Ignore if field is omitted */
+//       p?.sign === '-' ||
+//       /** Ignore if default fields and field is not in projection */
+//       (!defaultFields && !p) ||
+//       /** Ignore if default fields enabled and fields is exclusive */
+//       (defaultFields && field.exclusive && !p)
+//     ) {
+//       continue;
+//     }
+//
+//     if (field.type instanceof ComplexType && typeof p?.projection === 'object') {
+//       target[fieldName] = {};
+//       prepare(field.type, target[fieldName], p.projection);
+//       continue;
+//     }
+//     target[fieldName] = 1;
+//   }
+//   /** Add additional fields */
+//   if (dataType.additionalFields) {
+//     for (k of projectionKeysSet.values()) {
+//       const n = projectionKeysSet[k];
+//       if (n?.sign !== '-') target[k] = 1;
+//     }
+//   }
+// }
+//
+// // function __prepareProjection(
+// //   dataType: ComplexType,
+// //   args: {
+// //     pick?: string[];
+// //     omit?: string[];
+// //     include?: string[];
+// //   },
+// // ): any {
+// //   let includes: string[] | undefined;
+// //   let excludes: string[] | undefined;
+// //
+// //   if (args.include && !args.pick) {
+// //     includes = includes || [];
+// //     for (const [k, f] of dataType.fields) {
+// //       if (f.exclusive) continue;
+// //       if (f.type instanceof ComplexType) includes.push(k + '.*');
+// //       else includes.push(k);
+// //     }
+// //   }
+// //
+// //   if (args.pick) {
+// //     includes = includes || [];
+// //     for (const k of args.pick) {
+// //       const f = dataType.getField(k);
+// //       if (f.type instanceof ComplexType) includes.push(k + '.*');
+// //       else includes.push(k);
+// //     }
+// //   }
+// //
+// //   if (args.include) {
+// //     includes = includes || [];
+// //     for (const k of args.include) {
+// //       const f = dataType.getField(k);
+// //       if (f.type instanceof ComplexType) includes.push(k + '.*');
+// //       else includes.push(k);
+// //     }
+// //   }
+// //
+// //   if (args.omit) {
+// //     excludes = excludes || [];
+// //     for (const k of args.omit) {
+// //       const f = dataType.getField(k);
+// //       if (f.type instanceof ComplexType) excludes.push(k + '.*');
+// //       else excludes.push(k);
+// //     }
+// //   }
+// //
+// //   return omitNullish({
+// //     includes,
+// //     excludes,
+// //   });
+// // }

package/esm/{transform-sort.js → adapter-utils/prepare-sort.js}

@@ -1,4 +1,4 @@
-export default function transformSort(sort) {
+export default function prepareSort(sort) {
     if (!(sort && sort.length))
         return;
     const out = [];

package/esm/elastic-adapter.js

@@ -1,47 +1,84 @@
-import { Collection, omitNullish, Singleton } from '@opra/common';
-import _transformFilter from './transform-filter.js';
-import _transformKeyValues from './transform-key-values.js';
-import _transformProjection from './transform-projection.js';
-import _transformSort from './transform-sort.js';
+// import { SearchRequest } from '@elastic/elasticsearch/lib/api/types';
+// import { TransportRequestOptions } from '@elastic/transport';
+// import { omitNullish } from '@opra/common';
+import _prepareFilter from './adapter-utils/prepare-filter.js';
+import _prepareKeyValues from './adapter-utils/prepare-key-values.js';
+// import _prepareProjection from './adapter-utils/prepare-projection.js';
+import _prepareSort from './adapter-utils/prepare-sort.js';
 export var ElasticAdapter;
 (function (ElasticAdapter) {
-    ElasticAdapter.transformFilter = _transformFilter;
-    ElasticAdapter.transformKeyValues = _transformKeyValues;
-    ElasticAdapter.transformProjection = _transformProjection;
-    ElasticAdapter.transformSort = _transformSort;
-    function transformRequest(request) {
-        const { resource } = request;
-        if (resource instanceof Collection || resource instanceof Singleton) {
-            const { params, endpoint } = request;
-            let options = {};
-            switch (endpoint.name) {
-                case 'findMany': {
-                    let searchRequest = {};
-                    const filter = ElasticAdapter.transformFilter(params?.filter);
-                    if (filter)
-                        searchRequest.query = filter;
-                    if (params?.limit != null)
-                        searchRequest.size = params.limit;
-                    if (params?.skip != null)
-                        searchRequest.from = params.skip;
-                    if (params?.count)
-                        searchRequest.track_total_hits = true;
-                    if (params?.pick || params?.include || params?.omit)
-                        searchRequest._source = _transformProjection(resource.type, params);
-                    if (params?.sort)
-                        searchRequest.sort = _transformSort(params.sort);
-                    searchRequest = omitNullish(searchRequest);
-                    options = omitNullish(options);
-                    return {
-                        method: 'search',
-                        params: searchRequest,
-                        options,
-                        args: [searchRequest, options]
+    ElasticAdapter.prepareFilter = _prepareFilter;
+    ElasticAdapter.prepareKeyValues = _prepareKeyValues;
+    // export const prepareProjection = _prepareProjection;
+    ElasticAdapter.prepareSort = _prepareSort;
+    async function parseRequest(context) {
+        const { operation } = context;
+        if (operation.composition?.startsWith('Entity.') && operation.compositionOptions?.type) {
+            const controller = operation.owner;
+            switch (operation.composition) {
+                case 'Entity.Create': {
+                    const data = await context.getBody();
+                    const options = {
+                        projection: context.queryParams.projection,
                     };
+                    return { method: 'create', data, options };
                 }
+                case 'Entity.Delete': {
+                    const keyParam = operation.parameters.find(p => p.keyParam) || controller.parameters.find(p => p.keyParam);
+                    const key = keyParam && context.pathParams[String(keyParam.name)];
+                    const options = {
+                        filter: context.queryParams.filter,
+                    };
+                    return { method: 'delete', key, options };
+                }
+                case 'Entity.DeleteMany': {
+                    const options = {
+                        filter: context.queryParams.filter,
+                    };
+                    return { method: 'deleteMany', options };
+                }
+                case 'Entity.FindMany': {
+                    const options = {
+                        filter: context.queryParams.filter,
+                        projection: context.queryParams.projection,
+                        count: context.queryParams.count,
+                        limit: context.queryParams.limit,
+                        skip: context.queryParams.skip,
+                        sort: context.queryParams.sort,
+                    };
+                    return { method: 'findMany', options };
+                }
+                case 'Entity.Get': {
+                    const keyParam = operation.parameters.find(p => p.keyParam) || controller.parameters.find(p => p.keyParam);
+                    const key = keyParam && context.pathParams[String(keyParam.name)];
+                    const options = {
+                        projection: context.queryParams.projection,
+                        filter: context.queryParams.filter,
+                    };
+                    return { method: 'get', key, options };
+                }
+                case 'Entity.Update': {
+                    const data = await context.getBody();
+                    const keyParam = operation.parameters.find(p => p.keyParam) || controller.parameters.find(p => p.keyParam);
+                    const key = keyParam && context.pathParams[String(keyParam.name)];
+                    const options = {
+                        projection: context.queryParams.projection,
+                        filter: context.queryParams.filter,
+                    };
+                    return { method: 'update', key, data, options };
+                }
+                case 'Entity.UpdateMany': {
+                    const data = await context.getBody();
+                    const options = {
+                        filter: context.queryParams.filter,
+                    };
+                    return { method: 'updateMany', data, options };
+                }
+                default:
+                    break;
             }
         }
-        throw new TypeError(`Unimplemented request (${request.resource.kind}.${request.endpoint.name})`);
+        throw new Error(`This operation is not compatible to Elastic adapter`);
     }
-    ElasticAdapter.transformRequest = transformRequest;
+    ElasticAdapter.parseRequest = parseRequest;
 })(ElasticAdapter || (ElasticAdapter = {}));

package/esm/elastic-service.js

@@ -0,0 +1,140 @@
+import { ServiceBase } from '@opra/core';
+/**
+ * Class representing a ElasticSearch service for interacting with a collection.
+ * @extends ServiceBase
+ * @template T - The type of the documents in the collection.
+ */
+export class ElasticService extends ServiceBase {
+    /**
+     * Constructs a new instance
+     *
+     * @param dataType - The data type of the returning results
+     * @param indexName - The name of the index, or a function that returns the index name
+     * @param [options] - The options for the service
+     * @constructor
+     */
+    constructor(dataType, indexName, options) {
+        super();
+        this._inputCodecs = {};
+        this._outputCodecs = {};
+        this._dataType_ = dataType;
+        this.client = options?.client;
+        this.$commonFilter = this.$commonFilter || options?.commonFilter;
+        this.$interceptor = this.$interceptor || options?.interceptor;
+        this.$indexName = indexName;
+        this.$resourceName = options?.resourceName;
+        this.$idGenerator = options?.idGenerator;
+    }
+    /**
+     * Retrieves the index name.
+     *
+     * @protected
+     * @returns The index name.
+     * @throws {Error} If the index name is not defined.
+     */
+    getIndexName() {
+        const out = typeof this.$indexName === 'function' ? this.$indexName(this) : this.$indexName;
+        if (out)
+            return out;
+        throw new Error('indexName is not defined');
+    }
+    /**
+     * Retrieves the resource name.
+     *
+     * @protected
+     * @returns {string} The resource name.
+     * @throws {Error} If the resource name is not defined.
+     */
+    getResourceName() {
+        const out = typeof this.$resourceName === 'function' ? this.$resourceName(this) : this.$resourceName || this.getIndexName();
+        if (out)
+            return out;
+        throw new Error('resourceName is not defined');
+    }
+    /**
+     * Retrieves the OPRA data type
+     *
+     * @throws {NotAcceptableError} If the data type is not a ComplexType.
+     */
+    get dataType() {
+        if (!this._dataType)
+            this._dataType = this.context.document.node.getComplexType(this._dataType_);
+        return this._dataType;
+    }
+    /**
+     * Retrieves the codec for the specified operation.
+     *
+     * @param operation - The operation to retrieve the encoder for. Valid values are 'create' and 'update'.
+     */
+    getInputCodec(operation) {
+        let validator = this._inputCodecs[operation];
+        if (validator)
+            return validator;
+        const options = { projection: '*' };
+        if (operation === 'update')
+            options.partial = 'deep';
+        const dataType = this.dataType;
+        validator = dataType.generateCodec('decode', options);
+        this._inputCodecs[operation] = validator;
+        return validator;
+    }
+    /**
+     * Retrieves the codec.
+     */
+    getOutputCodec(operation) {
+        let validator = this._outputCodecs[operation];
+        if (validator)
+            return validator;
+        const options = { projection: '*', partial: 'deep' };
+        const dataType = this.dataType;
+        validator = dataType.generateCodec('decode', options);
+        this._outputCodecs[operation] = validator;
+        return validator;
+    }
+    /**
+     * Retrieves the ElasticSearch client.
+     *
+     * @protected
+     *
+     * @throws {Error} If the context or client is not set.
+     */
+    getClient() {
+        // @ts-ignore
+        const db = typeof this.client === 'function' ? this.client(this) : this.client;
+        if (!db)
+            throw new Error(`Client not set!`);
+        return db;
+    }
+    /**
+     * Generates an ID.
+     *
+     * @protected
+     * @returns The generated ID.
+     */
+    _generateId() {
+        return typeof this.$idGenerator === 'function' ? this.$idGenerator(this) : undefined;
+    }
+    /**
+     * Retrieves the common filter used for querying documents.
+     * This method is mostly used for security issues like securing multi-tenant applications.
+     *
+     * @protected
+     * @returns {QueryDslQueryContainer | Promise<QueryDslQueryContainer> | undefined} The common filter or a Promise
+     * that resolves to the common filter, or undefined if not available.
+     */
+    _getCommonFilter(info) {
+        return typeof this.$commonFilter === 'function' ? this.$commonFilter(info, this) : this.$commonFilter;
+    }
+    async _intercept(callback, info) {
+        try {
+            if (this.$interceptor)
+                return this.$interceptor(callback, info, this);
+            return callback();
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this._intercept);
+            await this.$onError?.(e, this);
+            throw e;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/elastic",
-  "version": "0.33.13",
+  "version": "1.0.0-alpha.18",
   "description": "Opra Elastic Search adapter package",
   "author": "Panates",
   "license": "MIT",
@@ -17,23 +17,28 @@
     "build:esm": "tsc -b tsconfig-build-esm.json",
     "postbuild": "cp README.md package.json ../../LICENSE ../../build/elastic && cp ../../package.cjs.json ../../build/elastic/cjs/package.json",
     "lint": "eslint . --max-warnings=0",
-    "test": "jest",
-    "cover": "jest --collect-coverage",
+    "lint:fix": "eslint . --max-warnings=0 --fix",
+    "format": "prettier . --write --log-level=warn",
+    "test": "jest --passWithNoTests",
+    "cover": "jest --passWithNoTests --collect-coverage",
     "clean": "npm run clean:src && npm run clean:test && npm run clean:dist && npm run clean:cover",
     "clean:src": "ts-cleanup -s src --all",
     "clean:test": "ts-cleanup -s test --all",
     "clean:dist": "rimraf ../../build/client",
     "clean:cover": "rimraf ../../coverage/client"
   },
+  "dependencies": {
+    "putil-isplainobject": "^1.1.5"
+  },
   "devDependencies": {
-    "@elastic/elasticsearch": "^8.11.0",
-    "@faker-js/faker": "^8.4.0",
-    "ts-gems": "^3.1.1"
+    "@elastic/elasticsearch": "^8.14.0",
+    "@faker-js/faker": "^8.4.1",
+    "ts-gems": "^3.4.0"
   },
   "peerDependencies": {
     "@elastic/elasticsearch": ">=8.7.0",
-    "@opra/common": "^0.33.13",
-    "@opra/core": "^0.33.13"
+    "@opra/common": "^1.0.0-alpha.18",
+    "@opra/core": "^1.0.0-alpha.18"
   },
   "type": "module",
   "module": "./esm/index.js",
@@ -57,4 +62,4 @@
     "elasticsearch",
     "adapter"
   ]
-}
+}

package/types/adapter-utils/prepare-filter.d.ts

@@ -0,0 +1,3 @@
+import '@opra/core';
+import { OpraFilter } from '@opra/common';
+export default function prepareFilter(ast: OpraFilter.Expression | undefined, negative?: boolean): any;

package/types/adapter-utils/prepare-key-values.d.ts

@@ -0,0 +1 @@
+export default function prepareKeyValues(keyValue: any, primaryKey?: string[]): Record<string, any>;

package/types/adapter-utils/prepare-sort.d.ts

@@ -0,0 +1 @@
+export default function prepareSort(sort?: string[]): any[] | undefined;

package/types/elastic-adapter.d.ts

@@ -1,12 +1,16 @@
-import { Request } from '@opra/core';
-import _transformFilter from './transform-filter.js';
-import _transformKeyValues from './transform-key-values.js';
-import _transformProjection from './transform-projection.js';
-import _transformSort from './transform-sort.js';
+import { HttpContext } from '@opra/core';
+import _prepareFilter from './adapter-utils/prepare-filter.js';
+import _prepareKeyValues from './adapter-utils/prepare-key-values.js';
+import _prepareSort from './adapter-utils/prepare-sort.js';
 export declare namespace ElasticAdapter {
-    const transformFilter: typeof _transformFilter;
-    const transformKeyValues: typeof _transformKeyValues;
-    const transformProjection: typeof _transformProjection;
-    const transformSort: typeof _transformSort;
-    function transformRequest(request: Request): any;
+    const prepareFilter: typeof _prepareFilter;
+    const prepareKeyValues: typeof _prepareKeyValues;
+    const prepareSort: typeof _prepareSort;
+    interface TransformedRequest {
+        method: 'create' | 'delete' | 'deleteMany' | 'get' | 'findMany' | 'update' | 'updateMany';
+        key?: any;
+        data?: any;
+        options: any;
+    }
+    function parseRequest(context: HttpContext): Promise<TransformedRequest>;
 }

package/types/elastic-service.d.ts

@@ -0,0 +1,147 @@
+import { Client } from '@elastic/elasticsearch';
+import { QueryDslQueryContainer } from '@elastic/elasticsearch/lib/api/types';
+import { ComplexType } from '@opra/common';
+import { ServiceBase } from '@opra/core';
+import { Type } from 'ts-gems';
+import { IsObject } from 'valgen';
+/**
+ * The namespace for the ElasticService.
+ *
+ * @namespace ElasticService
+ */
+export declare namespace ElasticService {
+    interface Options {
+        client?: ElasticService<any>['client'];
+        resourceName?: ElasticService<any>['$resourceName'];
+        commonFilter?: ElasticService<any>['$commonFilter'];
+        interceptor?: ElasticService<any>['$interceptor'];
+        idGenerator?: ElasticService<any>['$idGenerator'];
+        onError?: ElasticService<any>['$onError'];
+    }
+    type CrudOp = 'create' | 'read' | 'update' | 'delete';
+    interface CommandInfo {
+        crud: CrudOp;
+        method: string;
+        byId: boolean;
+        documentId?: any;
+        input?: Record<string, any>;
+        options?: Record<string, any>;
+    }
+}
+/**
+ * Class representing a ElasticSearch service for interacting with a collection.
+ * @extends ServiceBase
+ * @template T - The type of the documents in the collection.
+ */
+export declare class ElasticService<T extends object> extends ServiceBase {
+    protected _dataType_: Type | string;
+    protected _dataType: ComplexType;
+    protected _inputCodecs: Record<string, IsObject.Validator<T>>;
+    protected _outputCodecs: Record<string, IsObject.Validator<T>>;
+    /**
+     * Represents the name of a index in ElasticDB
+     */
+    $indexName: string | ((_this: any) => string);
+    /**
+     * Represents the name of a resource.
+     * @type {string}
+     */
+    $resourceName?: string | ((_this: any) => string);
+    /**
+     * Represents a ElasticDB database object.
+     */
+    client?: Client | ((_this: any) => Client);
+    /**
+     * Generates a new id for new inserting Document.
+     *
+     */
+    $idGenerator?: (_this: any) => any;
+    /**
+     * Callback function for handling errors.
+     *
+     * @param {unknown} error - The error object.
+     * @param _this - The context object.
+     */
+    $onError?: (error: unknown, _this: any) => void | Promise<void>;
+    /**
+     * Represents a common filter function for a ElasticService.
+     *
+     * @type {QueryDslQueryContainer | Function}
+     */
+    $commonFilter?: QueryDslQueryContainer | ((args: ElasticService.CommandInfo, _this: this) => QueryDslQueryContainer | Promise<QueryDslQueryContainer> | undefined);
+    /**
+     * Interceptor function for handling callback execution with provided arguments.
+     *
+     * @param callback - The callback function to be intercepted.
+     * @param {ElasticService.CommandInfo} info - The arguments object containing the following properties:
+     * @param _this - The reference to the current object.
+     * @returns - The promise that resolves to the result of the callback execution.
+     */
+    $interceptor?: (callback: () => any, info: ElasticService.CommandInfo, _this: any) => Promise<any>;
+    /**
+     * Constructs a new instance
+     *
+     * @param dataType - The data type of the returning results
+     * @param indexName - The name of the index, or a function that returns the index name
+     * @param [options] - The options for the service
+     * @constructor
+     */
+    constructor(dataType: Type | string, indexName: string, options?: ElasticService.Options);
+    /**
+     * Retrieves the index name.
+     *
+     * @protected
+     * @returns The index name.
+     * @throws {Error} If the index name is not defined.
+     */
+    getIndexName(): string;
+    /**
+     * Retrieves the resource name.
+     *
+     * @protected
+     * @returns {string} The resource name.
+     * @throws {Error} If the resource name is not defined.
+     */
+    getResourceName(): string;
+    /**
+     * Retrieves the OPRA data type
+     *
+     * @throws {NotAcceptableError} If the data type is not a ComplexType.
+     */
+    get dataType(): ComplexType;
+    /**
+     * Retrieves the codec for the specified operation.
+     *
+     * @param operation - The operation to retrieve the encoder for. Valid values are 'create' and 'update'.
+     */
+    getInputCodec(operation: string): IsObject.Validator<T>;
+    /**
+     * Retrieves the codec.
+     */
+    getOutputCodec(operation: string): IsObject.Validator<T>;
+    /**
+     * Retrieves the ElasticSearch client.
+     *
+     * @protected
+     *
+     * @throws {Error} If the context or client is not set.
+     */
+    getClient(): Client;
+    /**
+     * Generates an ID.
+     *
+     * @protected
+     * @returns The generated ID.
+     */
+    protected _generateId(): any;
+    /**
+     * Retrieves the common filter used for querying documents.
+     * This method is mostly used for security issues like securing multi-tenant applications.
+     *
+     * @protected
+     * @returns {QueryDslQueryContainer | Promise<QueryDslQueryContainer> | undefined} The common filter or a Promise
+     * that resolves to the common filter, or undefined if not available.
+     */
+    protected _getCommonFilter(info: ElasticService.CommandInfo): QueryDslQueryContainer | Promise<QueryDslQueryContainer> | undefined;
+    protected _intercept(callback: (...args: any[]) => any, info: ElasticService.CommandInfo): Promise<any>;
+}