onecore 0.0.20 → 0.0.24

package/lib/index.js

@@ -1 +1,89 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+  var extendStatics = function (d, b) {
+    extendStatics = Object.setPrototypeOf ||
+      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+      function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+  };
+  return function (d, b) {
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var ViewManager = (function () {
+  function ViewManager(repo) {
+    this.repo = repo;
+    this.metadata = this.metadata.bind(this);
+    this.keys = this.keys.bind(this);
+    this.all = this.all.bind(this);
+    this.load = this.load.bind(this);
+    this.exist = this.exist.bind(this);
+  }
+  ViewManager.prototype.metadata = function () {
+    return (this.repo.metadata ? this.repo.metadata() : undefined);
+  };
+  ViewManager.prototype.keys = function () {
+    return (this.repo.keys ? this.repo.keys() : []);
+  };
+  ViewManager.prototype.all = function (ctx) {
+    return (this.repo.all ? this.repo.all() : Promise.resolve([]));
+  };
+  ViewManager.prototype.load = function (id, ctx) {
+    return this.repo.load(id, ctx);
+    ;
+  };
+  ViewManager.prototype.exist = function (id, ctx) {
+    return (this.repo.exist ? this.repo.exist(id, ctx) : Promise.resolve(false));
+  };
+  return ViewManager;
+}());
+exports.ViewManager = ViewManager;
+var GenericManager = (function (_super) {
+  __extends(GenericManager, _super);
+  function GenericManager(repository) {
+    var _this = _super.call(this, repository) || this;
+    _this.repository = repository;
+    _this.insert = _this.insert.bind(_this);
+    _this.update = _this.update.bind(_this);
+    _this.patch = _this.patch.bind(_this);
+    _this.save = _this.save.bind(_this);
+    _this.delete = _this.delete.bind(_this);
+    return _this;
+  }
+  GenericManager.prototype.insert = function (obj, ctx) {
+    return this.repository.insert(obj, ctx);
+    ;
+  };
+  GenericManager.prototype.update = function (obj, ctx) {
+    return this.repository.update(obj, ctx);
+    ;
+  };
+  GenericManager.prototype.patch = function (obj, ctx) {
+    return (this.repository.patch ? this.repository.patch(obj, ctx) : Promise.resolve(-1));
+  };
+  GenericManager.prototype.save = function (obj, ctx) {
+    return (this.repository.save ? this.repository.save(obj, ctx) : Promise.resolve(-1));
+  };
+  GenericManager.prototype.delete = function (id, ctx) {
+    return (this.repository.delete ? this.repository.delete(id, ctx) : Promise.resolve(-1));
+  };
+  return GenericManager;
+}(ViewManager));
+exports.GenericManager = GenericManager;
+var Manager = (function (_super) {
+  __extends(Manager, _super);
+  function Manager(find, repo) {
+    var _this = _super.call(this, repo) || this;
+    _this.find = find;
+    _this.search = _this.search.bind(_this);
+    return _this;
+  }
+  Manager.prototype.search = function (s, limit, offset, fields) {
+    return this.find(s, limit, offset, fields);
+  };
+  return Manager;
+}(GenericManager));
+exports.Manager = Manager;exports.DefaultViewService = ViewManager;exports.DefaultGenericService = GenericManager;exports.GenericSearchManager = Manager;exports.DefaultService = GenericManager;exports.DefaultGenericSearchService = GenericManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onecore",
-  "version": "0.0.20",
+  "version": "0.0.24",
   "description": "onecore",
   "main": "./lib/index.js",
   "types": "./src/index.ts",
@@ -17,7 +17,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git@github.com/core-ts/onecore"
+    "url": "git@github.com/core-ts/core"
   },
   "keywords": [
     "one",

package/src/db.ts

@@ -0,0 +1,19 @@
+import {Attribute} from './metadata';
+export interface Statement {
+  query: string;
+  params?: any[];
+}
+export interface SimpleDB {
+  driver: string;
+  query<T>(sql: string): Promise<T[]>;
+}
+interface StringMap {
+  [key: string]: string;
+}
+export interface DB {
+  driver: string;
+  param(i: number): string;
+  exec(sql: string, args?: any[], ctx?: any): Promise<number>;
+  execBatch(statements: Statement[], firstSuccess?: boolean, ctx?: any): Promise<number>;
+  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T[]>;
+}

package/src/index.ts

@@ -1,5 +1,7 @@
 export {Locale} from './formatter';
 
+export * from './db';
+
 export {Mapper} from './formatter';
 export {LocaleMapper} from './formatter';
 export {Formatter} from './formatter';
@@ -26,8 +28,8 @@ export {DataLoader} from './loader';
 
 export * from './model';
 
-import {GenericSearchRepository} from './repository/GenericSearchRepository';
-export {GenericSearchRepository as Repository};
+import {GenericRepository} from './repository/GenericRepository';
+export {GenericRepository as Repository};
 
 export * from './repository/ViewRepository';
 export * from './repository/GenericRepository';
@@ -62,3 +64,76 @@ export * from './mail/config';
 export * from './location';
 export * from './video';
 export * from './health';
+export * from './logger';
+
+import { Attributes } from './metadata';
+import { Filter, SearchResult } from './model';
+// import { GenericRepository } from './repository/GenericRepository';
+import { ViewRepository } from './repository/ViewRepository';
+// import { GenericSearchService } from './service/GenericSearchService';
+import { GenericService } from './service/GenericService';
+import { ViewService } from './service/ViewService';
+
+export class ViewManager<T, ID> implements ViewService<T, ID> {
+  constructor(private repo: ViewRepository<T, ID>) {
+    this.metadata = this.metadata.bind(this);
+    this.keys = this.keys.bind(this);
+    this.all = this.all.bind(this);
+    this.load = this.load.bind(this);
+    this.exist = this.exist.bind(this);
+  }
+  metadata(): Attributes|undefined {
+    return (this.repo.metadata ? this.repo.metadata() : undefined);
+  }
+  keys(): string[] {
+    return (this.repo.keys ? this.repo.keys() : []);
+  }
+  all(ctx?: any): Promise<T[]> {
+    return (this.repo.all ? this.repo.all() : Promise.resolve([]));
+  }
+  load(id: ID, ctx?: any): Promise<T | null> {
+    return this.repo.load(id, ctx);;
+  }
+  exist(id: ID, ctx?: any): Promise<boolean> {
+    return (this.repo.exist ? this.repo.exist(id, ctx) : Promise.resolve(false));
+  }
+}
+export class GenericManager<T, ID> extends ViewManager<T, ID> implements GenericService<T, ID, number> {
+  constructor(protected repository: GenericRepository<T, ID>) {
+    super(repository);
+    this.insert = this.insert.bind(this);
+    this.update = this.update.bind(this);
+    this.patch = this.patch.bind(this);
+    this.save = this.save.bind(this);
+    this.delete = this.delete.bind(this);
+  }
+  insert(obj: T, ctx?: any): Promise<number> {
+    return this.repository.insert(obj, ctx);;
+  }
+  update(obj: T, ctx?: any): Promise<number> {
+    return this.repository.update(obj, ctx);;
+  }
+  patch(obj: T, ctx?: any): Promise<number> {
+    return (this.repository.patch ? this.repository.patch(obj, ctx) : Promise.resolve(-1));
+  }
+  save(obj: T, ctx?: any): Promise<number> {
+    return (this.repository.save ? this.repository.save(obj, ctx) : Promise.resolve(-1));
+  }
+  delete(id: ID, ctx?: any): Promise<number> {
+    return (this.repository.delete ? this.repository.delete(id, ctx) : Promise.resolve(-1));
+  }
+}
+export class Manager<T, ID, S extends Filter> extends GenericManager<T, ID> implements GenericSearchService<T, ID, number, S> {
+  constructor(public find: (s: S, offset?: number, skip?: number|string, fields?: string[]) => Promise<SearchResult<T>>, repo: GenericRepository<T, ID>) {
+    super(repo);
+    this.search = this.search.bind(this);
+  }
+  search(s: S, limit?: number, offset?: number|string, fields?: string[]): Promise<SearchResult<T>> {
+    return this.find(s, limit, offset, fields);
+  }
+}
+export const DefaultViewService = ViewManager;
+export const DefaultGenericService = GenericManager;
+export const GenericSearchManager = Manager;
+export const DefaultService = GenericManager;
+export const DefaultGenericSearchService = GenericManager;

package/src/logger.ts

@@ -0,0 +1,31 @@
+export interface SimpleMap {
+  [key: string]: string|number|boolean|Date;
+}
+export interface LogMap {
+  time: string;
+  level: string;
+  msg: string;
+}
+export interface LogMapConfig {
+  time?: string;
+  level?: string;
+  msg?: string;
+}
+export interface Logger {
+  level: number;
+  trace(msg: string, m?: SimpleMap, ctx?: any): void;
+  debug(msg: string, m?: SimpleMap, ctx?: any): void;
+  info(msg: string, m?: SimpleMap, ctx?: any): void;
+  warn(msg: string, m?: SimpleMap, ctx?: any): void;
+  error(msg: string, m?: SimpleMap, ctx?: any): void;
+  panic(msg: string, m?: SimpleMap, ctx?: any): void;
+  fatal(msg: string, m?: SimpleMap, ctx?: any): void;
+  isLevelEnabled(level: number): boolean;
+  isTraceEnabled(): boolean;
+  isDebugEnabled(): boolean;
+  isInfoEnabled(): boolean;
+  isWarnEnabled(): boolean;
+  isErrorEnabled(): boolean;
+  isPanicEnabled(): boolean;
+  isFatalEnabled(): boolean;
+}

package/src/metadata.ts

@@ -1,7 +1,7 @@
 export type DataType = 'ObjectId' | 'date' | 'datetime' | 'time'
-    | 'boolean' | 'number' | 'integer' | 'string' | 'text'
-    | 'object' | 'array' | 'binary'
-    | 'primitives' | 'booleans' | 'numbers' | 'integers' | 'strings' | 'dates' | 'datetimes' | 'times';
+  | 'boolean' | 'number' | 'integer' | 'string' | 'text'
+  | 'object' | 'array' | 'binary'
+  | 'primitives' | 'booleans' | 'numbers' | 'integers' | 'strings' | 'dates' | 'datetimes' | 'times';
 export type FormatType = 'currency' | 'percentage' | 'email' | 'url' | 'phone' | 'fax' | 'ipv4' | 'ipv6';
 export type MatchType = 'equal' | 'prefix' | 'contain' | 'max' | 'min'; // contain: default for string, min: default for Date, number
 
@@ -9,21 +9,26 @@ export interface Model {
   name?: string;
   attributes: Attributes;
   source?: string;
+  table?: string;
   collection?: string;
-  model?: any;
-  schema?: any;
+  // for mongo lowcode
+  sort?: string;
+  geo?: string;
+  latitude?: string;
+  longitude?: string;
 }
-
 export interface Attribute {
   name?: string;
   field?: string;
+  column?: string;
   type?: DataType;
   format?: FormatType;
   required?: boolean;
   match?: MatchType;
-  defaultValue?: any;
+  default?: string|number|Date|boolean;
   key?: boolean;
   unique?: boolean;
+  enum?: string[] | number[];
   q?: boolean;
   noinsert?: boolean;
   noupdate?: boolean;
@@ -36,13 +41,15 @@ export interface Attribute {
   lt?: number;
   precision?: number;
   scale?: number;
-  exp?: RegExp|string;
+  exp?: RegExp | string;
   code?: string;
   noformat?: boolean;
   ignored?: boolean;
   jsonField?: string;
   link?: string;
   typeof?: Attributes;
+  true?: string|number;
+  false?: string|number;
 }
 export interface Attributes {
   [key: string]: Attribute;

package/src/mq.ts

@@ -21,41 +21,41 @@ export interface Writer<T, R, ID> {
   write(data: T, attributes?: StringMap, id?: ID): Promise<R>;
 }
 
-export interface SimpleProducer<T, R, ID> {
+export interface Producer<T, R, ID> {
   produce(to: string, data: T, attributes?: StringMap, id?: ID): Promise<R>;
 }
-export interface SimplePublisher<T, R, ID> {
+export interface Publisher<T, R, ID> {
   publish(to: string, data: T, attributes?: StringMap, id?: ID): Promise<R>;
 }
-export interface SimpleSender<T, R, ID> {
+export interface Sender<T, R, ID> {
   send(to: string, data: T, attributes?: StringMap, id?: ID): Promise<R>;
 }
-export interface SimpleWriter<T, R, ID> {
+export interface Writer<T, R, ID> {
   write(to: string, data: T, attributes?: StringMap, id?: ID): Promise<R>;
 }
 
-export interface SimpleConsumer<T> {
-  consume(handle: (data: T, attributes?: StringMap) => Promise<number>): void;
+export interface SimpleConsumer<T, R> {
+  consume(handle: (data: T, attributes?: StringMap, raw?: R) => Promise<number>): void;
 }
 export interface SimpleSubscriber<T, R> {
-  subscribe(handle: (data: T, attributes?: StringMap) => Promise<number>): void;
+  subscribe(handle: (data: T, attributes?: StringMap, raw?: R) => Promise<number>): void;
 }
-export interface SimpleReceiver<T> {
-  receive(handle: (data: T, attributes?: StringMap) => Promise<number>): void;
+export interface SimpleReceiver<T, R> {
+  receive(handle: (data: T, attributes?: StringMap, raw?: R) => Promise<number>): void;
 }
-export interface SimpleReader<T> {
-  read(handle: (data: T, attributes?: StringMap) => Promise<number>): void;
+export interface SimpleReader<T, R> {
+  read(handle: (data: T, attributes?: StringMap, raw?: R) => Promise<number>): void;
 }
 
-export interface Consumer<T, ID, R> {
+export interface MessageConsumer<T, ID, R> {
   consume(data: Message<T, ID, R>): void;
 }
-export interface Subscriber<T, ID, R> {
+export interface MessageSubscriber<T, ID, R> {
   subscribe(handle: (data: Message<T, ID, R>) => Promise<number>): void;
 }
-export interface Receiver<T, ID, R> {
+export interface MessageReceiver<T, ID, R> {
   receive(handle: (data: Message<T, ID, R>) => Promise<number>): void;
 }
-export interface Reader<T, ID, R> {
+export interface MessageReader<T, ID, R> {
   read(handle: (data: Message<T, ID, R>) => Promise<number>): void;
 }

package/src/repository/GenericRepository.ts

@@ -1,9 +1,9 @@
 import {ViewRepository} from './ViewRepository';
 
-export interface GenericRepository<T, ID, R> extends ViewRepository<T, ID> {
-  insert(obj: T, ctx?: any): Promise<R>;
-  update(obj: T, ctx?: any): Promise<R>;
-  patch?(obj: T, ctx?: any): Promise<R>;
-  save?(obj: T, ctx?: any): Promise<R>;
+export interface GenericRepository<T, ID> extends ViewRepository<T, ID> {
+  insert(obj: T, ctx?: any): Promise<number>;
+  update(obj: T, ctx?: any): Promise<number>;
+  patch?(obj: T, ctx?: any): Promise<number>;
+  save?(obj: T, ctx?: any): Promise<number>;
   delete?(id: ID, ctx?: any): Promise<number>;
 }

package/src/repository/GenericSearchRepository.ts

@@ -2,6 +2,6 @@ import {Filter} from '../model';
 import {GenericRepository} from './GenericRepository';
 import {SearchRepository} from './SearchRepository';
 
-export interface GenericSearchRepository<T, ID, R, S extends Filter>
-  extends GenericRepository<T, ID, R>, SearchRepository<T, S> {
+export interface GenericSearchRepository<T, ID, S extends Filter>
+  extends GenericRepository<T, ID>, SearchRepository<T, S> {
 }