@opra/core 0.1.1 → 0.2.0

package/esm/implementation/query-context.js

@@ -1,6 +1,5 @@
-import { ResponsiveMap } from '@opra/schema';
 import { OpraURLSearchParams } from '@opra/url';
-import { HttpHeaders } from '../enums/index.js';
+import { HeadersMap } from './headers-map.js';
 export class QueryContext {
     service;
     executionContext;
@@ -9,14 +8,21 @@ export class QueryContext {
     headers;
     parentValue;
     resultPath;
+    responseHeaders;
     response;
+    errors = [];
+    status;
     userContext;
     continueOnError;
     constructor(args) {
-        Object.assign(this, args);
-        this.response = new QueryResponse();
+        // Object.assign(this, args);
+        this.service = args.service;
+        this.executionContext = args.executionContext;
+        this.query = args.query;
+        // this.response = new QueryResponse();
         this.params = this.params || new OpraURLSearchParams();
-        this.headers = this.headers || new ResponsiveMap();
+        this.headers = new HeadersMap(args.headers);
+        this.responseHeaders = new HeadersMap();
         this.resultPath = this.resultPath || '';
     }
     get type() {
@@ -28,15 +34,3 @@ export class QueryContext {
         return this.executionContext;
     }
 }
-export class QueryResponse {
-    headers;
-    errors = [];
-    status;
-    value;
-    total;
-    constructor(args) {
-        if (args)
-            Object.assign(this, args);
-        this.headers = new ResponsiveMap(undefined, Array.from(Object.values(HttpHeaders)));
-    }
-}

package/esm/index.d.ts

@@ -1,9 +1,7 @@
 import "reflect-metadata";
 export * from './types.js';
 export * from './enums/index.js';
-export * from './exception/index.js';
 export * from './interfaces/execution-context.interface.js';
-export * from './interfaces/query.interface.js';
 export * from './interfaces/entity-service.interface.js';
 export * from './implementation/query-context.js';
 export * from './implementation/adapter.js';

package/esm/index.js

@@ -1,9 +1,7 @@
 import "reflect-metadata";
 export * from './types.js';
 export * from './enums/index.js';
-export * from './exception/index.js';
 export * from './interfaces/execution-context.interface.js';
-export * from './interfaces/query.interface.js';
 export * from './interfaces/entity-service.interface.js';
 export * from './implementation/query-context.js';
 export * from './implementation/adapter.js';

package/esm/interfaces/entity-service.interface.d.ts

@@ -1,17 +1,19 @@
 import { Maybe } from 'ts-gems';
+import { IResource, OpraResource } from '@opra/schema';
 import { EntityOutput } from '@sqb/connect';
 import { QueryContext } from '../implementation/query-context.js';
 export interface IEntityService {
     processRequest(ctx: QueryContext): any;
 }
-export declare abstract class EntityResourceController<T> {
-    search(ctx: QueryContext): Promise<Maybe<EntityOutput<T>>[]>;
-    get(ctx: QueryContext): Promise<Maybe<EntityOutput<T>>>;
-    count(ctx: QueryContext): Promise<Maybe<number>>;
-    create(ctx: QueryContext): Promise<Maybe<EntityOutput<T>>>;
-    update(ctx: QueryContext): Promise<Maybe<EntityOutput<T>>>;
+export declare abstract class EntityResourceController<T, TOutput = EntityOutput<T>> implements IResource {
+    search(ctx: QueryContext): Promise<TOutput[]>;
+    get(ctx: QueryContext): Promise<Maybe<TOutput>>;
+    count(ctx: QueryContext): Promise<number>;
+    create(ctx: QueryContext): Promise<TOutput>;
+    update(ctx: QueryContext): Promise<Maybe<TOutput>>;
     updateMany(ctx: QueryContext): Promise<Maybe<number>>;
     delete(ctx: QueryContext): Promise<Maybe<boolean | number>>;
     deleteMany(ctx: QueryContext): Promise<Maybe<number>>;
+    abstract init(service: OpraResource): void | Promise<void>;
     abstract getService(ctx: QueryContext): IEntityService | Promise<IEntityService>;
 }

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

@@ -1,15 +1,60 @@
 import { Maybe } from 'ts-gems';
+import { EntityResource, EntityType, OpraAnyQuery, 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 { OpraQuery } from '../interfaces/query.interface.js';
-import { EntityInput, EntityOutput, QueryType } from '../types.js';
-export interface JsonDataServiceAgs<T> {
-    resourceName: string;
-    data: T[];
-    primaryKey: string;
+import { EntityInput, EntityOutput } from '../types.js';
+export interface JsonDataServiceOptions {
+    resourceName?: string;
+    defaultLimit?: number;
+    data?: any[];
+}
+export declare class JsonDataService<T, TOutput = EntityOutput<T>> implements IEntityService {
+    readonly resource: EntityResource;
+    private _status;
+    private _initError;
+    private _dbName;
+    private _initData?;
+    defaultLimit: number;
+    constructor(resource: EntityResource, options?: JsonDataServiceOptions);
+    get dataType(): EntityType;
+    get primaryKey(): string;
+    get resourceName(): string;
+    close(): Promise<void>;
+    processRequest(ctx: QueryContext): Promise<any>;
+    get(keyValue: any, options?: JsonDataService.GetOptions): Promise<Maybe<TOutput>>;
+    count(options?: JsonDataService.SearchOptions): Promise<number>;
+    search(options?: JsonDataService.SearchOptions): Promise<TOutput[]>;
+    create(data: EntityInput<T>, options?: JsonDataService.CreateOptions): Promise<TOutput>;
+    update(keyValue: any, data: EntityInput<T>, options?: JsonDataService.UpdateOptions): Promise<Maybe<TOutput>>;
+    updateMany(data: EntityInput<T>, options?: JsonDataService.UpdateManyOptions): Promise<number>;
+    delete(keyValue: any): Promise<boolean>;
+    deleteMany(options?: JsonDataService.DeleteManyOptions): Promise<number>;
+    private _waitInitializing;
+    protected _init(): Promise<void>;
+    protected _prepare(query: OpraAnyQuery): {
+        method: OpraSchema.EntityMethod;
+        options: any;
+        keyValue?: any;
+        values?: any;
+        args: any[];
+    };
+    protected _convertSelect(args: {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    }): string[];
+    protected _convertFilter(str: string | Expression | undefined | {}): any;
 }
 export declare namespace JsonDataService {
+    type CountOptions = {
+        filter?: string | Expression | {};
+    };
+    type CreateOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    };
     type GetOptions = {
         pick?: string[];
         omit?: string[];
@@ -19,16 +64,12 @@ export declare namespace JsonDataService {
         pick?: string[];
         omit?: string[];
         include?: string[];
+        filter?: any[];
+        sort?: string[];
         limit?: number;
         skip?: number;
         distinct?: boolean;
-        total?: boolean;
-        filter?: string | Expression | {};
-    };
-    type CreateOptions = {
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
+        count?: boolean;
     };
     type UpdateOptions = {
         pick?: string[];
@@ -36,33 +77,9 @@ export declare namespace JsonDataService {
         include?: string[];
     };
     type UpdateManyOptions = {
-        filter?: string | Expression | {};
+        filter?: any[];
     };
     type DeleteManyOptions = {
-        filter?: string | Expression | {};
-    };
-}
-export declare class JsonDataService<T, TOutput = EntityOutput<T>> implements IEntityService {
-    resourceName: string;
-    data: T[];
-    primaryKey: string;
-    constructor(args: JsonDataServiceAgs<T>);
-    processRequest(ctx: QueryContext): any;
-    get(keyValue: any, options?: JsonDataService.GetOptions): Maybe<TOutput>;
-    count(options?: JsonDataService.SearchOptions): Maybe<number>;
-    search(options?: JsonDataService.SearchOptions): Maybe<TOutput>[];
-    create(data: EntityInput<T>, options?: JsonDataService.CreateOptions): TOutput;
-    update(keyValue: any, data: EntityInput<T>, options?: JsonDataService.UpdateOptions): Maybe<TOutput>;
-    updateMany(data: EntityInput<T>, options?: JsonDataService.UpdateManyOptions): number;
-    delete(keyValue: any): boolean;
-    deleteMany(options?: JsonDataService.DeleteManyOptions): number;
-    static filterFields(obj: any, pick: string[] | undefined, omit: string[] | undefined, include: string[] | undefined): any;
-    static prepare(query: OpraQuery): {
-        method: QueryType;
-        options: any;
-        keyValue?: any;
-        values?: any;
-        args: any[];
+        filter?: any[];
     };
-    static convertFilter(str: string | Expression | undefined | {}): any;
 }