@opra/core 0.3.0 → 0.5.0

package/esm/adapter/http-adapter.js

@@ -0,0 +1,237 @@
+import { HeadersMap, HttpHeaders, HttpStatus } from '@opra/common';
+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 { 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,14 @@
+import { HeadersMap, HttpStatus } from '@opra/common';
 import { OpraException } from '@opra/exception';
-import { OpraAnyQuery, OpraApi } from '@opra/schema';
-import { SearchParams } from '@opra/url';
-import { HttpStatus } from '../enums/index.js';
+import { OpraDocument, OpraQuery } from '@opra/schema';
+import { OpraURLSearchParams } from '@opra/url';
 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 { HeadersMap } from '@opra/common';
 import { OpraURLSearchParams } from '@opra/url';
-import { HeadersMap } from './headers-map.js';
 export class QueryContext {
     service;
     executionContext;

package/esm/index.d.ts

@@ -1,11 +1,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

@@ -1,11 +1,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[];
+    };
+}

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

@@ -0,0 +1,92 @@
+import _ from 'lodash';
+import { SingletonResourceInfo } from '@opra/schema';
+export class JsonSingletonService {
+    dataType;
+    _data;
+    constructor(dataType, options) {
+        this.dataType = dataType;
+        this._data = options?.data;
+    }
+    async processRequest(ctx) {
+        const prepared = this._prepare(ctx.query);
+        const fn = this[prepared.method];
+        if (!fn)
+            throw new TypeError(`Unimplemented method (${prepared.method})`);
+        // @ts-ignore
+        return fn.apply(this, prepared.args);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    get(options) {
+        return this._data;
+    }
+    _prepare(query) {
+        if (query.resource instanceof SingletonResourceInfo) {
+            if (query.dataType !== this.dataType)
+                throw new TypeError(`Query data type (${query.dataType.name}) ` +
+                    `differs from JsonCollectionService data type (${this.dataType.name})`);
+        }
+        switch (query.method) {
+            case 'create': {
+                const options = _.omitBy({
+                    pick: query.pick,
+                    omit: query.omit,
+                    include: query.include
+                }, _.isNil);
+                const { data } = query;
+                return {
+                    method: query.method,
+                    values: data,
+                    options,
+                    args: [data, options]
+                };
+            }
+            case 'get': {
+                if (query.kind === 'CollectionGetQuery') {
+                    const options = _.omitBy({
+                        pick: query.pick,
+                        omit: query.omit,
+                        include: query.include
+                    }, _.isNil);
+                    const keyValue = query.keyValue;
+                    return {
+                        method: query.method,
+                        keyValue,
+                        options,
+                        args: [keyValue, options]
+                    };
+                }
+                if (query.kind === 'FieldGetQuery') {
+                    // todo
+                }
+                break;
+            }
+            case 'update': {
+                const options = _.omitBy({
+                    pick: query.pick,
+                    omit: query.omit,
+                    include: query.include
+                }, _.isNil);
+                const { data } = query;
+                const keyValue = query.keyValue;
+                return {
+                    method: query.method,
+                    keyValue: query.keyValue,
+                    values: data,
+                    options,
+                    args: [keyValue, data, options]
+                };
+            }
+            case 'delete': {
+                const options = {};
+                const keyValue = query.keyValue;
+                return {
+                    method: query.method,
+                    keyValue,
+                    options,
+                    args: [keyValue, options]
+                };
+            }
+        }
+        throw new Error(`Unimplemented query type "${query.method}"`);
+    }
+}

package/esm/types.d.ts

@@ -1,8 +1,2 @@
-import { Builtin, DeepPickWritable } from 'ts-gems';
-export declare type EntityInput<T> = DeepNullableIfPartial<DeepPickWritable<T>>;
-export declare type EntityOutput<T> = DeepNullableIfPartial<T>;
-export declare type DeepNullableIfPartial<T> = _DeepNullableIfPartial<T>;
-declare type _DeepNullableIfPartial<T> = T extends Builtin ? T : T extends Promise<infer U> ? Promise<DeepNullableIfPartial<U>> : T extends (infer U)[] ? DeepNullableIfPartial<U>[] : {
-    [P in keyof T]?: DeepNullableIfPartial<Exclude<T[P], undefined>> | null;
-};
-export {};
+import { PartialInput, PartialOutput } from '@opra/common';
+export { PartialInput, PartialOutput };

package/esm/utils/create-i18n.d.ts

@@ -1,3 +1,3 @@
 import { I18n } from '@opra/i18n';
-import { OpraAdapter } from '../implementation/adapter.js';
+import { OpraAdapter } from '../adapter/adapter.js';
 export declare function createI18n(options?: OpraAdapter.I18nOptions): Promise<I18n>;