@opra/core 0.0.8 → 0.0.11

package/esm/implementation/schema-generator.js

@@ -3,6 +3,7 @@ import { DATATYPE_METADATA, DATATYPE_PROPERTIES, OpraSchema } from '@opra/schema
 import { RESOURCE_METADATA } from '../constants.js';
 import { isConstructor, resolveClassAsync } from '../utils/class-utils.js';
 import { builtinClassMap, internalDataTypes, primitiveDataTypeNames } from '../utils/internal-data-types.js';
+var isDataType = OpraSchema.isDataType;
 const entityMethods = ['search', 'count', 'create', 'get', 'update', 'updateMany', 'delete', 'deleteMany'];
 export class SchemaGenerator {
     _dataTypes = {};
@@ -11,24 +12,16 @@ export class SchemaGenerator {
         //
     }
     async addDataType(thunk) {
-        let schema;
         thunk = isPromise(thunk) ? await thunk : thunk;
-        if (typeof thunk === 'function' && !isConstructor(thunk))
-            thunk = await thunk();
-        if (!isConstructor(thunk) || OpraSchema.isDataType(thunk))
-            throw new TypeError(`Function must return a type class or type schema`);
-        if (isConstructor(thunk)) {
+        if (typeof thunk === 'function') {
+            if (!isConstructor(thunk))
+                return this.addDataType(await thunk());
+            if (builtinClassMap.has(thunk))
+                return this.addDataType(builtinClassMap.get(thunk));
             const ctor = thunk;
             const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, ctor);
             if (!metadata)
                 throw new TypeError(`Class "${ctor}" has no type metadata`);
-            schema = this._dataTypes[metadata.name];
-            if (schema) {
-                if (schema.kind !== metadata.kind ||
-                    (OpraSchema.isComplexType(schema) && schema.ctor !== ctor))
-                    throw new Error(`An other instance of "${schema.name}" data type previously defined`);
-                return schema;
-            }
             // Add base data type
             let base;
             let baseCtor = Object.getPrototypeOf(ctor);
@@ -39,49 +32,43 @@ export class SchemaGenerator {
                 const baseSchema = await this.addDataType(baseCtor);
                 base = baseSchema.name;
             }
-            if (OpraSchema.isComplexType(metadata) || OpraSchema.isEntityType(metadata)) {
-                schema = {
-                    ...metadata,
-                    ctor,
-                    base
-                };
-                const properties = Reflect.getMetadata(DATATYPE_PROPERTIES, ctor.prototype);
-                if (properties) {
-                    for (const [k, p] of Object.entries(properties)) {
-                        let type;
-                        if (isConstructor(p.type) && builtinClassMap.has(p.type))
-                            type = builtinClassMap.get(p.type);
-                        else if (typeof p.type === 'function' || typeof p.type === 'object') {
-                            const t = await this.addDataType(p.type);
-                            type = t.name;
-                        }
-                        else
-                            type = p.type || 'string';
-                        if (internalDataTypes.has(type) && !this._dataTypes[type])
-                            this._dataTypes[type] = internalDataTypes.get(type.toLowerCase());
-                        schema.properties = schema.properties || {};
-                        schema.properties[k] = { ...p, type };
+            const schema = {
+                ...metadata,
+                ctor,
+                base
+            };
+            const properties = Reflect.getMetadata(DATATYPE_PROPERTIES, ctor.prototype);
+            if (properties) {
+                for (const [k, p] of Object.entries(properties)) {
+                    let type = p.type || 'string';
+                    if (typeof type !== 'string') {
+                        const propSchema = await this.addDataType(type);
+                        type = propSchema.name;
                     }
+                    else {
+                        if (internalDataTypes.has(type))
+                            await this.addDataType(internalDataTypes.get(type));
+                    }
+                    schema.properties = schema.properties || {};
+                    schema.properties[k] = { ...p, type };
                 }
             }
-            else if (OpraSchema.isSimpleType(metadata)) {
-                if (!primitiveDataTypeNames.includes(metadata.type))
-                    throw new Error(`"type" of SimpleType schema must be one of enumerated value (${primitiveDataTypeNames})`);
-                schema = {
-                    ...metadata
-                };
-            }
-            else
-                /* istanbul ignore next */
-                throw new TypeError(`Invalid metadata`);
+            return this.addDataType(schema);
         }
-        else if (OpraSchema.isDataType(thunk)) {
-            schema = thunk;
-        }
-        else
+        if (!isDataType(thunk))
             throw new TypeError(`Invalid data type schema`);
-        this._dataTypes[schema.name] = schema;
-        return schema;
+        // Check if datatype previously added
+        const currentSchema = this._dataTypes[thunk.name];
+        if (currentSchema) {
+            if (!(currentSchema.kind === thunk.kind && currentSchema.ctor && currentSchema.ctor === thunk.ctor))
+                throw new Error(`An other instance of "${currentSchema.name}" data type previously defined`);
+            return currentSchema;
+        }
+        if (OpraSchema.isSimpleType(thunk) && !primitiveDataTypeNames.includes(thunk.type))
+            throw new Error(`"type" of SimpleType schema must be one of enumerated value (${primitiveDataTypeNames})`);
+        return this._dataTypes[thunk.name] = {
+            ...thunk
+        };
     }
     async addResource(instance) {
         if (isConstructor(instance))

package/esm/index.d.ts

@@ -4,11 +4,10 @@ export * from './types.js';
 export * from './enums/index.js';
 export * from './exception/index.js';
 export * from './decorators/entity-resource.decorator.js';
-export * from './interfaces/http-context.interface.js';
-export * from './interfaces/execution-query.interface.js';
+export * from './interfaces/execution-context.interface.js';
+export * from './interfaces/query.interface.js';
 export * from './interfaces/resource-container.interface.js';
-export * from './interfaces/user-context.interface.js';
-export * from './implementation/execution-context.js';
+export * from './implementation/query-context.js';
 export * from './implementation/opra-document.js';
 export * from './implementation/opra-service.js';
 export * from './implementation/schema-generator.js';

package/esm/index.js

@@ -4,11 +4,10 @@ export * from './types.js';
 export * from './enums/index.js';
 export * from './exception/index.js';
 export * from './decorators/entity-resource.decorator.js';
-export * from './interfaces/http-context.interface.js';
-export * from './interfaces/execution-query.interface.js';
+export * from './interfaces/execution-context.interface.js';
+export * from './interfaces/query.interface.js';
 export * from './interfaces/resource-container.interface.js';
-export * from './interfaces/user-context.interface.js';
-export * from './implementation/execution-context.js';
+export * from './implementation/query-context.js';
 export * from './implementation/opra-document.js';
 export * from './implementation/opra-service.js';
 export * from './implementation/schema-generator.js';

package/esm/interfaces/execution-context.interface.d.ts

@@ -0,0 +1,39 @@
+export declare type ContextType = 'http' | 'ws' | 'rpc';
+export declare type PlatformType = 'express';
+export declare namespace IExecutionContext {
+    type OnFinishArgs = {
+        userContext: any;
+        failed: boolean;
+    };
+}
+export interface IExecutionContext {
+    getType(): ContextType;
+    getPlatform(): PlatformType;
+    switchToHttp(): IHttpExecutionContext;
+    onFinish(fn: (args: IExecutionContext.OnFinishArgs) => void | Promise<void>): any;
+}
+export interface IHttpExecutionContext extends IExecutionContext {
+    getRequest(): any;
+    getResponse(): any;
+    getRequestWrapper(): IHttpRequestWrapper;
+    getResponseWrapper(): IHttpResponseWrapper;
+}
+export interface IHttpRequestWrapper {
+    getInstance(): any;
+    getUrl(): string;
+    getMethod(): string;
+    getHeaderNames(): string[];
+    getHeader(name: string): string | undefined;
+    getHeaders(): Record<string, any>;
+    getBody(): any;
+}
+export interface IHttpResponseWrapper {
+    getInstance(): any;
+    getStatus(): number | undefined;
+    setStatus(value: number): this;
+    getHeaderNames(name: string): string[];
+    getHeader(name: string): string | undefined;
+    setHeader(name: string, value: string): this;
+    send(body: any): this;
+    end(): this;
+}

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

@@ -0,0 +1,108 @@
+import { StrictOmit } from 'ts-gems';
+import { OpraSchema } from '@opra/schema';
+import { Expression } from '@opra/url';
+import { EntityResourceHandler } from '../implementation/resource/entity-resource-handler.js';
+import { KeyValue, OperationType, QueryScope, QueryType } from '../types.js';
+export declare type OpraQuery = OpraCreateQuery | OpraGetQuery | OpraSearchQuery | OpraUpdateQuery | OpraUpdateManyQuery | OpraDeleteQuery | OpraDeleteManyQuery;
+interface BaseOpraQuery {
+    queryType: QueryType;
+    scope: QueryScope;
+    operation: OperationType;
+}
+export interface OpraCreateQuery extends BaseOpraQuery {
+    queryType: 'create';
+    scope: 'collection';
+    operation: 'create';
+    resource: EntityResourceHandler;
+    data: {};
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+}
+export interface OpraGetQuery extends BaseOpraQuery {
+    queryType: 'get';
+    scope: 'instance';
+    operation: 'read';
+    resource: EntityResourceHandler;
+    keyValue: KeyValue;
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    nested?: OpraPropertyQuery;
+}
+export interface OpraPropertyQuery extends BaseOpraQuery {
+    queryType: 'get';
+    scope: 'property';
+    operation: 'read';
+    property: OpraSchema.Property;
+    nested?: OpraPropertyQuery;
+}
+export interface OpraUpdateQuery extends BaseOpraQuery {
+    queryType: 'update';
+    scope: 'instance';
+    operation: 'update';
+    resource: EntityResourceHandler;
+    keyValue: KeyValue;
+    data: {};
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+}
+export interface OpraUpdateManyQuery extends BaseOpraQuery {
+    queryType: 'updateMany';
+    scope: 'collection';
+    operation: 'update';
+    resource: EntityResourceHandler;
+    filter?: string | Expression;
+    data: {};
+}
+export interface OpraDeleteQuery extends BaseOpraQuery {
+    queryType: 'delete';
+    scope: 'instance';
+    operation: 'delete';
+    resource: EntityResourceHandler;
+    keyValue: KeyValue;
+}
+export interface OpraDeleteManyQuery extends BaseOpraQuery {
+    queryType: 'deleteMany';
+    scope: 'collection';
+    operation: 'delete';
+    resource: EntityResourceHandler;
+    filter?: string | Expression;
+}
+export interface OpraSearchQuery extends BaseOpraQuery {
+    queryType: 'search';
+    scope: 'collection';
+    operation: 'read';
+    resource: EntityResourceHandler;
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    filter?: string | Expression;
+    limit?: number;
+    skip?: number;
+    distinct?: boolean;
+    count?: boolean;
+    sort?: string[];
+}
+export declare type CreateQueryOptions = StrictOmit<OpraCreateQuery, 'queryType' | 'scope' | 'operation' | 'resource' | 'data'>;
+export declare type GetQueryOptions = StrictOmit<OpraGetQuery, 'queryType' | 'scope' | 'operation' | 'resource' | 'keyValue'>;
+export declare type SearchQueryOptions = StrictOmit<OpraSearchQuery, 'queryType' | 'scope' | 'operation' | 'resource'>;
+export declare type UpdateQueryOptions = StrictOmit<OpraUpdateQuery, 'queryType' | 'scope' | 'operation' | 'resource' | 'keyValue' | 'data'>;
+export declare type UpdateManyQueryOptions = StrictOmit<OpraUpdateManyQuery, 'queryType' | 'scope' | 'operation' | 'resource' | 'data'>;
+export declare type DeleteManyQueryOption = StrictOmit<OpraDeleteManyQuery, 'queryType' | 'scope' | 'operation' | 'resource'>;
+export declare namespace OpraQuery {
+    function forCreate(resource: EntityResourceHandler, values: {}, options?: CreateQueryOptions): OpraCreateQuery;
+    function forGet(resource: EntityResourceHandler, key: KeyValue, options?: GetQueryOptions): OpraGetQuery;
+    function forSearch(resource: EntityResourceHandler, options?: SearchQueryOptions): OpraSearchQuery;
+    function forGetProperty(property: OpraSchema.Property, options?: StrictOmit<OpraPropertyQuery, 'queryType' | 'scope' | 'operation' | 'property'>): OpraPropertyQuery;
+    function forUpdate(resource: EntityResourceHandler, keyValue: KeyValue, values: any, options?: UpdateQueryOptions): OpraUpdateQuery;
+    function forUpdateMany(resource: EntityResourceHandler, values: any, options?: UpdateManyQueryOptions): OpraUpdateManyQuery;
+    function forDelete(resource: EntityResourceHandler, key: KeyValue): OpraDeleteQuery;
+    function forDeleteMany(resource: EntityResourceHandler, options?: DeleteManyQueryOption): OpraDeleteManyQuery;
+    function isCreateQuery(q: any): q is OpraCreateQuery;
+    function isSearchQuery(q: any): q is OpraSearchQuery;
+    function isReadQuery(q: any): q is OpraGetQuery;
+    function isDeleteQuery(q: any): q is OpraDeleteQuery;
+}
+export {};

package/esm/interfaces/{execution-query.interface.js → query.interface.js}

@@ -1,8 +1,8 @@
 import _ from 'lodash';
 import { ComplexType } from '../implementation/data-type/complex-type.js';
 import { stringPathToObjectTree } from '../utils/string-path-to-object-tree.js';
-export var ExecutionQuery;
-(function (ExecutionQuery) {
+export var OpraQuery;
+(function (OpraQuery) {
     function forCreate(resource, values, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
@@ -13,14 +13,14 @@ export var ExecutionQuery;
         const out = {
             queryType: 'create',
             scope: 'collection',
-            operationType: 'create',
+            operation: 'create',
             resource,
             data: values
         };
         Object.assign(out, _.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forCreate = forCreate;
+    OpraQuery.forCreate = forCreate;
     function forGet(resource, key, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
@@ -32,14 +32,14 @@ export var ExecutionQuery;
         const out = {
             queryType: 'get',
             scope: 'instance',
-            operationType: 'read',
+            operation: 'read',
             resource,
             keyValue: key
         };
         Object.assign(out, _.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forGet = forGet;
+    OpraQuery.forGet = forGet;
     function forSearch(resource, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
@@ -52,24 +52,24 @@ export var ExecutionQuery;
         const out = {
             queryType: 'search',
             scope: 'collection',
-            operationType: 'read',
+            operation: 'read',
             resource
         };
         Object.assign(out, _.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forSearch = forSearch;
+    OpraQuery.forSearch = forSearch;
     function forGetProperty(property, options) {
         const out = {
             queryType: 'get',
             scope: 'property',
-            operationType: 'read',
+            operation: 'read',
             property
         };
         Object.assign(out, _.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forGetProperty = forGetProperty;
+    OpraQuery.forGetProperty = forGetProperty;
     function forUpdate(resource, keyValue, values, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
@@ -81,7 +81,7 @@ export var ExecutionQuery;
         const out = {
             queryType: 'update',
             scope: 'instance',
-            operationType: 'update',
+            operation: 'update',
             resource,
             keyValue,
             data: values
@@ -89,58 +89,58 @@ export var ExecutionQuery;
         Object.assign(out, _.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forUpdate = forUpdate;
+    OpraQuery.forUpdate = forUpdate;
     function forUpdateMany(resource, values, options) {
         const out = {
             queryType: 'updateMany',
             scope: 'collection',
-            operationType: 'update',
+            operation: 'update',
             resource,
             data: values
         };
         Object.assign(out, _.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forUpdateMany = forUpdateMany;
+    OpraQuery.forUpdateMany = forUpdateMany;
     function forDelete(resource, key) {
         checkKeyFields(resource, key);
         return {
             queryType: 'delete',
             scope: 'instance',
-            operationType: 'delete',
+            operation: 'delete',
             resource,
             keyValue: key
         };
     }
-    ExecutionQuery.forDelete = forDelete;
+    OpraQuery.forDelete = forDelete;
     function forDeleteMany(resource, options) {
         const out = {
             queryType: 'deleteMany',
             scope: 'collection',
-            operationType: 'delete',
+            operation: 'delete',
             resource,
         };
         Object.assign(out, _.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forDeleteMany = forDeleteMany;
+    OpraQuery.forDeleteMany = forDeleteMany;
     function isCreateQuery(q) {
         return q && typeof q === 'object' && q.scope === 'collection' && q.queryType === 'create';
     }
-    ExecutionQuery.isCreateQuery = isCreateQuery;
+    OpraQuery.isCreateQuery = isCreateQuery;
     function isSearchQuery(q) {
         return q && typeof q === 'object' && q.scope === 'collection' && q.queryType === 'search';
     }
-    ExecutionQuery.isSearchQuery = isSearchQuery;
+    OpraQuery.isSearchQuery = isSearchQuery;
     function isReadQuery(q) {
         return q && typeof q === 'object' && q.scope === 'instance' && q.queryType === 'read';
     }
-    ExecutionQuery.isReadQuery = isReadQuery;
+    OpraQuery.isReadQuery = isReadQuery;
     function isDeleteQuery(q) {
         return q && typeof q === 'object' && q.scope === 'instance' && q.queryType === 'delete';
     }
-    ExecutionQuery.isDeleteQuery = isDeleteQuery;
-})(ExecutionQuery || (ExecutionQuery = {}));
+    OpraQuery.isDeleteQuery = isDeleteQuery;
+})(OpraQuery || (OpraQuery = {}));
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 function checkKeyFields(resource, key) {
     if (!resource.dataType.primaryKey)

package/esm/services/entity-resource-controller.d.ts

@@ -1,17 +1,17 @@
 import { Maybe } from 'ts-gems';
 import { EntityOutput } from '@sqb/connect';
-import { ExecutionContext } from '../implementation/execution-context.js';
+import { QueryContext } from '../implementation/query-context.js';
 export interface IEntityService {
-    processRequest(ctx: ExecutionContext): any;
+    processRequest(ctx: QueryContext): any;
 }
 export declare abstract class EntityResourceController<T> {
-    search(ctx: ExecutionContext): Promise<Maybe<EntityOutput<T>>[]>;
-    get(ctx: ExecutionContext): Promise<Maybe<EntityOutput<T>>>;
-    count(ctx: ExecutionContext): Promise<Maybe<number>>;
-    create(ctx: ExecutionContext): Promise<Maybe<EntityOutput<T>>>;
-    update(ctx: ExecutionContext): Promise<Maybe<EntityOutput<T>>>;
-    updateMany(ctx: ExecutionContext): Promise<Maybe<number>>;
-    delete(ctx: ExecutionContext): Promise<Maybe<boolean | number>>;
-    deleteMany(ctx: ExecutionContext): Promise<Maybe<number>>;
-    abstract getService(ctx: ExecutionContext): IEntityService | Promise<IEntityService>;
+    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>>>;
+    updateMany(ctx: QueryContext): Promise<Maybe<number>>;
+    delete(ctx: QueryContext): Promise<Maybe<boolean | number>>;
+    deleteMany(ctx: QueryContext): Promise<Maybe<number>>;
+    abstract getService(ctx: QueryContext): IEntityService | Promise<IEntityService>;
 }

package/esm/types.d.ts

@@ -1,4 +1,4 @@
-import type { DeepPartial, DeepPickJson, DeepPickWritable, Type } from 'ts-gems';
+import type { Type } from 'ts-gems';
 export declare type Thunk<T> = T | (() => T);
 export declare type ThunkAsync<T> = T | Promise<T> | (() => T) | (() => Promise<T>);
 export declare type TypeThunk<T = any> = Thunk<Type<T>>;
@@ -7,5 +7,3 @@ export declare type QueryScope = 'collection' | 'instance' | 'property';
 export declare type QueryType = 'create' | 'get' | 'update' | 'patch' | 'delete' | 'execute' | 'search' | 'updateMany' | 'patchMany' | 'deleteMany';
 export declare type OperationType = 'create' | 'read' | 'update' | 'patch' | 'delete' | 'execute';
 export declare type KeyValue = string | number | boolean | object;
-export declare type PartialInput<T> = DeepPartial<DeepPickWritable<DeepPickJson<T>>>;
-export declare type PartialOutput<T> = DeepPartial<DeepPickJson<T>>;

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

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

package/esm/utils/create-i18n.js

@@ -0,0 +1,16 @@
+import path from 'path';
+import { I18n } from '@opra/i18n';
+import { getCallerFile } from './get-caller-file.util.js';
+export async function createI18n(options) {
+    const opts = {
+        ...options,
+        resourceDirs: undefined
+    };
+    const instance = I18n.createInstance(opts);
+    await instance.init();
+    await instance.loadResourceDir(path.resolve(getCallerFile(), '../../../i18n'));
+    if (options?.resourceDirs)
+        for (const dir of options.resourceDirs)
+            await instance.loadResourceDir(dir);
+    return instance;
+}

package/esm/utils/get-caller-file.util.d.ts

@@ -0,0 +1 @@
+export declare function getCallerFile(position?: number): any;

package/esm/utils/get-caller-file.util.js

@@ -0,0 +1,15 @@
+export function getCallerFile(position = 1) {
+    if (position >= Error.stackTraceLimit) {
+        throw new TypeError('getCallerFile(position) requires position be less then Error.stackTraceLimit but position was: `' +
+            position + '` and Error.stackTraceLimit was: `' + Error.stackTraceLimit + '`');
+    }
+    const oldPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = (_, stack) => stack;
+    const stack = new Error().stack;
+    Error.prepareStackTrace = oldPrepareStackTrace;
+    if (stack !== null && typeof stack === 'object') {
+        // stack[0] holds this file
+        // stack[1] holds where this function was called
+        return stack[position] ? stack[position].getFileName() : undefined;
+    }
+}

package/esm/utils/internal-data-types.d.ts

@@ -1,4 +1,5 @@
+import { Type } from 'ts-gems';
 import { OpraSchema } from '@opra/schema';
-export declare const builtinClassMap: Map<any, any>;
 export declare const primitiveDataTypeNames: string[];
+export declare const builtinClassMap: Map<Type<any>, OpraSchema.DataType>;
 export declare const internalDataTypes: Map<string, OpraSchema.DataType>;

package/esm/utils/internal-data-types.js

@@ -1,41 +1,78 @@
+export const primitiveDataTypeNames = ['boolean', 'number', 'string', 'null'];
 export const builtinClassMap = new Map();
-builtinClassMap.set(Boolean, 'boolean');
-builtinClassMap.set(Number, 'number');
-builtinClassMap.set(String, 'string');
-builtinClassMap.set(Buffer, 'buffer');
-export const primitiveDataTypeNames = ['boolean', 'number', 'integer', 'string'];
 export const internalDataTypes = new Map();
 const internalDataTypeArray = [
     {
         kind: 'SimpleType',
         name: 'boolean',
         type: 'boolean',
-        description: 'Simple true/false value'
+        description: 'Simple true/false value',
+        ctor: Boolean
+    },
+    {
+        kind: 'SimpleType',
+        name: 'string',
+        type: 'string',
+        description: 'A sequence of characters',
+        ctor: String
     },
     {
         kind: 'SimpleType',
         name: 'number',
         type: 'number',
-        description: 'Both Integer as well as Floating-Point numbers'
+        description: 'Both Integer as well as Floating-Point numbers',
+        ctor: Number
     },
     {
         kind: 'SimpleType',
-        name: 'string',
-        type: 'string',
-        description: 'A sequence of characters'
+        name: 'integer',
+        type: 'number',
+        base: 'number',
+        description: 'Integer number',
+        ctor: Number
     },
     {
         kind: 'ComplexType',
         name: 'object',
         description: 'Object type with additional properties',
-        additionalProperties: true
+        additionalProperties: true,
+        ctor: Object
     },
     {
         kind: 'SimpleType',
-        name: 'integer',
-        type: 'number',
-        base: 'number',
-        description: 'Integer number'
+        name: 'date',
+        type: 'string',
+        description: 'Date',
+        format: 'date',
+        ctor: Date
+    },
+    {
+        kind: 'SimpleType',
+        name: 'date-time',
+        type: 'string',
+        description: 'Date time value',
+        format: 'date-time',
+        ctor: Date
+    },
+    {
+        kind: 'SimpleType',
+        name: 'time',
+        type: 'string',
+        description: 'Time value',
+        format: 'time',
+        ctor: String
+    },
+    {
+        kind: 'SimpleType',
+        name: 'buffer',
+        type: 'string',
+        description: 'Buffer value',
+        format: 'base64',
+        ctor: Buffer
     }
 ];
-internalDataTypeArray.forEach(sch => internalDataTypes.set(sch.name, sch));
+internalDataTypeArray.forEach(sch => {
+    internalDataTypes.set(sch.name, sch);
+    if (sch.ctor && !builtinClassMap.has(sch.ctor))
+        builtinClassMap.set(sch.ctor, sch);
+});

package/i18n/en/error.json

@@ -0,0 +1,12 @@
+{
+  "BAD_REQUEST": "Bad request",
+  "FAILED_DEPENDENCY": "The request failed due to failure of a previous request",
+  "FORBIDDEN": "You are not authorized to perform this action",
+  "INTERNAL_SERVER_ERROR": "Internal server error",
+  "METHOD_NOT_ALLOWED": "Method Not Allowed",
+  "NOT_FOUND": "Not found",
+  "UNAUTHORIZED": "You have not been authenticated to perform this action",
+  "UNPROCESSABLE_ENTITY": "Unprocessable entity",
+
+  "RESOURCE_CONFLICT": "There is already an other {{resource}} resource with same field values ({{fields}})"
+}