onecore 0.6.3 → 0.6.6

package/README.md

@@ -4,154 +4,140 @@
 
 `onecore` provides the common contracts, metadata model, and reusable application-layer base classes used throughout the Core TS ecosystem.
 
-It allows libraries such as **sql-core**, **mysql2-core**, **postgres-kit**, **mongodb-kit**, **validation-core**, **cache-plus**, **redis-plus**, **message-processing**, **nats-plus**, **redis-messaging**, **rabbitmq-transport**, **logger-core**, and **health-service** to work together through a unified API.
+It is designed to let infrastructure libraries and applications share the same abstractions without coupling application code to a specific database, messaging system, validation implementation, cache, or framework.
 
-## Features
-
-* Common interfaces for enterprise applications
-* Unified metadata model (`Attribute`)
-* Reusable CRUD and Search use-case base classes
-* Zero-cost abstractions through TypeScript interfaces
-* Tree-shakeable architecture
-* Works in both backend and frontend applications
-* No framework dependency
-* Fully written in TypeScript
-
----
-
-# Installation
+## Installation
 
 ```bash
 npm install onecore
 ```
 
----
+## What is onecore?
 
-# Why onecore?
-
-Enterprise applications often use many infrastructure libraries.
-
-For example:
+Large applications commonly depend on many infrastructure libraries:
 
-* Database
-* Validation
 * Cache
-* Message Queue
 * Logging
 * Health Check
-* Import/Export
-
-Without a shared foundation, every library exposes its own interfaces and metadata.
-
-```text
-Repository      (sql)
-Validator       (validation)
-Producer        (mq)
-Logger          (logger)
-Cache           (cache)
-```
-
-`onecore` provides a single common language for the entire ecosystem.
-
-```ts
-import {
-    Repository,
-    Validator,
-    Producer,
-    CachePort,
-    Logger,
-    HealthChecker
-} from "onecore";
-```
-
-Applications only depend on **onecore**, while implementation libraries implement these contracts.
-
----
+* Validation
+* Database
+  * DB
+  * Transaction
+  * Statement
+  * Repository
+* Service
+* Message Queue
+* Import / Export
+* HTTP clients
+* Localization
 
-# Ecosystem
+Without a shared foundation, each library tends to define its own interfaces and metadata.
 
-```
-                                 Applications
-        ┌───────────────────────────────────────────────────────────────┐
-        │                                                               │
-        │  React Apps • REST APIs • Microservices • Workers • CLI       │
-        │                                                               │
-        └───────────────────────────────────────────────────────────────┘
-                                      ▲
-                                      │
-                           Reusable Use Cases (Optional)
-                     CRUD • Search • View • Generic Services
-                                      ▲
-                                      │
-    ┌─────────────────────────────────────────────────────────────────────────────────┐
-    │                                onecore                                          │
-    │                                                                                 │
-    │  • Common Interfaces                                                            │
-    │  • Unified Attribute Metadata                                                   │
-    │  • Locale & Currency                                                            │
-    │  • Shared Models                                                                │
-    │  • Reusable Service Layer                                                       │
-    └─────────────────────────────────────────────────────────────────────────────────┘
-         ▲                  ▲                  ▲                  ▲                 ▲
-         │                  │                  │                  │                 │
-         │                  │                  │                  │                 │
-┌────────────────┐ ┌────────────────┐ ┌──────────────────┐ ┌────────────────┐ ┌────────────────┐
-│    Database    │ │   Validation   │ │   Messaging      │ │ Import / Export│ │     Cache      │
-├────────────────┤ ├────────────────┤ ├──────────────────┤ ├────────────────┤ ├────────────────┤
-│ sql-core       │ │validation-core │ │message-processing│ │import-service  │ │ cache-plus     │
-│ mysql2-core    │ │                │ │nats-plus         │ │export-kit      │ │ redis-plus     │
-│ postgres-kit   │ │                │ │redis-messaging   │ │                │ │                │
-│ oracle-core    │ │                │ │rabbitmq-transport│ │                │ │                │
-│ mssql-core     │ │                │ │activemq          │ │                │ │                │
-│ mongodb-kit    │ │                │ │ibmmq-plus        │ │                │ │                │
-└────────────────┘ └────────────────┘ └──────────────────┘ └────────────────┘ └────────────────┘
+`onecore` provides a common set of contracts so that these libraries can work together through a consistent API.
 
+```text
+                         Application
+                              │
+                         Use Cases
+                              │
+                    ┌─────────┴─────────┐
+                    │      onecore      │
+                    │                   │
+                    │    Interfaces     │
+                    │    Attribute      │
+                    │    Transaction    │
+                    │    Repository     │
+                    │    Use Cases      │
+                    └─────────┬─────────┘
+                              │
+        ┌──────────┬──────────┼──────────┬──────────┐
+        │          │          │          │          │
+    Database   Validation   Cache    Messaging   Logging
 ```
 
-All libraries share the same interfaces defined by `onecore`.
-
----
+The implementation packages depend on these contracts, while application code can depend on the contracts rather than concrete infrastructure implementations.
 
-# Zero-Cost Abstractions
+## Features
 
-One of the goals of `onecore` is to provide a common API **without adding runtime overhead**.
+* Shared TypeScript interfaces for the Core TS ecosystem
+  * Unified `Attribute` metadata model
+  * `ErrorMessage` for data validation
+  * Generic `Filter` and `SearchResult` models
+* Database executor and transaction abstractions
+  * Type-safe database parameter abstraction
+  * Repository abstractions for CRUD and search
+* Reusable CRUD and Search use-case classes
 
-## Interfaces
+* Interfaces with no runtime representation after TypeScript compilation
+  * No framework dependency
+  * Suitable for both backend and frontend projects
+  * Tree-shakeable runtime code
+## Unified metadata
 
-Interfaces disappear after TypeScript compilation.
+The central concept in `onecore` is `Attribute`.
 
 ```ts
-import { Repository, Validator } from "onecore";
+export interface Attribute {
+  name?: string
+  field?: string
+  column?: string
+  type?: DataType
+  format?: FormatType
+  required?: boolean
+
+  key?: boolean
+  unique?: boolean
+
+  enum?: string[] | number[]
+
+  noinsert?: boolean
+  noupdate?: boolean
+  nopatch?: boolean
+
+  version?: boolean
+  createdAt?: boolean
+  updatedAt?: boolean
+
+  length?: number
+  min?: number | Date | string
+  max?: number | Date | string
+  gt?: number | Date | string
+  lt?: number | Date | string
+
+  precision?: number
+  scale?: number
+}
 ```
 
-The generated JavaScript contains no implementation from `onecore`.
-
-## Base Classes
-
-If an application extends one of the reusable CRUD or Search use-case classes, only those classes are included in the final bundle.
-
-Modern bundlers such as Webpack, Rollup, Vite, and esbuild tree-shake unused code automatically.
-
-This allows frontend and backend projects to share the same package while keeping bundles minimal.
+Unlike persistence-specific or validation-specific metadata, `Attribute` is the canonical metadata model shared across the entire ecosystem.
 
----
+`Attribute` is intended to be shared by multiple parts of an application instead of maintaining separate metadata definitions for every subsystem.
 
-# Unified Metadata
+For example, the same metadata can describe:
 
-The most important type in `onecore` is `Attribute`.
+* Database mapping
+* Validation
+* Search
+* Formatting
+* Import
+* Export
+* Serialization
 
-Unlike persistence-specific or validation-specific metadata, `Attribute` is the canonical metadata model shared across the entire ecosystem.
+Individual libraries consume only the properties relevant to them.
 
 ```
                   Attribute
                       │
       ┌───────────────┼────────────────┐
       │               │                │
- Validation       Database        Import/Export
+  Validation      Database       Import/Export
       │               │                │
-validation-core   sql-core        import-service
-                 mysql2-core        export-kit
-                 postgres-kit
+validation-core   sql-core       import-service
+                 postgres-kit      export-kit
+                 mysql2-core
+                 oracle-core
+                 mssql-core
+                 cassandra-core
                  mongodb-kit
 ```
 
@@ -190,31 +176,411 @@ The same metadata definition can therefore be used for
 
 without duplication.
 
----
+## Data types
 
-# Shared Interfaces
+`onecore` defines a common `DataType` model:
 
-`onecore` defines the common contracts used by the ecosystem.
+```ts
+export type DataType =
+  | 'ObjectId'
+  | 'date'
+  | 'datetime'
+  | 'time'
+  | 'boolean'
+  | 'number'
+  | 'integer'
+  | 'string'
+  | 'text'
+  | 'object'
+  | 'array'
+  | 'binary'
+  | 'primitives'
+  | 'booleans'
+  | 'numbers'
+  | 'integers'
+  | 'strings'
+  | 'dates'
+  | 'datetimes'
+  | 'times'
+```
 
-## Database
+Scalar and collection types can therefore share the same metadata system.
 
-* Repository
-* GenericRepository
-* SearchRepository
-* Transaction
+Formatting is represented separately:
+
+```ts
+export type FormatType =
+  | 'currency'
+  | 'percentage'
+  | 'email'
+  | 'url'
+  | 'phone'
+  | 'fax'
+  | 'ipv4'
+  | 'ipv6'
+```
+
+## Database abstraction
+
+`onecore` provides a small database-independent execution contract.
+
+```ts
+export interface Executor {
+  driver: string
+  param(i: number): string
+  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T[]>
+  execute(sql: string, args?: any[]): Promise<number>
+  executeBatch(statements: Statement[], requireFirstAffected?: boolean): Promise<number>
+}
+```
+
+A database implementation is responsible for adapting this interface to its native driver.
+
+### Parameter abstraction
+
+Different databases use different parameter syntaxes.
+
+For example:
+
+```text
+PostgreSQL   $1 $2 $3
+MySQL        ? ? ?
+Oracle       :1 :2 :3
+SQL Server   @p1 @p2 @p3
+```
+
+`Executor.param()` allows higher-level SQL-building code to generate database-specific parameters without depending on a particular driver.
+
+### Statements
+
+A batch operation is represented by:
+
+```ts
+export interface Statement {
+  query: string
+  params?: any[]
+}
+```
+
+This keeps batch execution independent of the underlying database implementation.
+
+## Transactions
+
+Transactions extend the same executor abstraction:
+
+```ts
+export interface Transaction extends Executor {
+  commit(): Promise<void>
+  rollback(): Promise<void>
+}
+```
+
+A database provides transactions through:
+
+```ts
+export interface DB extends Executor {
+  beginTransaction(): Promise<Transaction>
+}
+```
+
+This allows repository code to use either the normal database executor or a transaction without knowing the underlying connection type.
+
+For example:
+
+```ts
+const tx = await db.beginTransaction()
+
+try {
+  await userRepository.create(user, tx)
+  await accountRepository.create(account, tx)
+
+  await tx.commit()
+} catch (err) {
+  await tx.rollback()
+  throw err
+}
+```
+
+The transaction abstraction is particularly useful when several repositories participate in the same operation.
+
+## Repository abstraction
+
+`onecore` defines generic repository contracts for CRUD and search operations.
+
+### CRUDRepository
+
+```ts
+export interface CRUDRepository<T, ID> {
+  load(id: ID, tx?: Transaction): Promise<T | null>
+  create(obj: T, tx?: Transaction): Promise<number>
+  update(obj: T, tx?: Transaction): Promise<number>
+  patch(obj: Partial<T>, tx?: Transaction): Promise<number>
+  delete(id: ID, tx?: Transaction): Promise<number>
+}
+```
+
+The optional `Transaction` parameter allows the same repository method to participate in a larger transaction.
+
+Normal operation:
+
+```ts
+await repository.create(user)
+```
+
+Transactional operation:
+
+```ts
+await repository.create(user, tx)
+```
+
+### SearchRepository
+
+```ts
+export interface SearchRepository<T, F extends Filter> {
+  search(
+    filter: F,
+    limit: number,
+    offset?: number | string,
+    fields?: string[],
+    tx?: Transaction
+  ): Promise<SearchResult<T>>
+}
+```
+
+The generic filter model is:
+
+```ts
+export interface Filter {
+  page?: number
+  limit: number
+  fields?: string[]
+  sort?: string
+  q?: string
+}
+```
+
+Search results are represented as:
+
+```ts
+export interface SearchResult<T> {
+  list: T[]
+  total?: number
+  next?: string
+}
+```
+
+This allows implementations to support result counts as well as cursor-style pagination.
+
+## Repository
+
+CRUD and search repositories can be combined:
+
+```ts
+export interface Repository<T, ID, F extends Filter>
+  extends CRUDRepository<T, ID>, SearchRepository<T, F> {
+}
+```
+
+An application can therefore define:
+
+```ts
+interface UserFilter extends Filter {
+  active?: boolean
+  role?: string
+}
+
+type UserRepository = Repository<User, string, UserFilter>
+```
+
+## Reusable use cases
+
+`onecore` includes reusable application-layer classes so applications do not have to repeatedly write trivial forwarding logic.
+
+### SearchUseCase
+
+```ts
+export class SearchUseCase<T, F extends Filter> {
+  constructor(
+    protected repository: SearchRepository<T, F>
+  ) {}
+
+  search(filter: F, limit: number, page?: number | string,
+        fields?: string[]): Promise<SearchResult<T>> {
+    return this.repository.search(filter, limit, page, fields)
+  }
+}
+```
+
+### CRUDUseCase
+
+```ts
+export class CRUDUseCase<T, ID> {
+  constructor(protected repository: CRUDRepository<T, ID>) {}
+
+  load(id: ID): Promise<T | null> {
+    return this.repository.load(id)
+  }
+  create(obj: T): Promise<number> {
+    return this.repository.create(obj)
+  }
+  update(obj: T): Promise<number> {
+    return this.repository.update(obj)
+  }
+  patch(obj: Partial<T>): Promise<number> {
+    return this.repository.patch(obj)
+  }
+  delete(id: ID): Promise<number> {
+    return this.repository.delete(id)
+  }
+}
+```
+
+### UseCase
+
+For applications that need both CRUD and search operations:
+
+```ts
+export class UseCase<T, ID, F extends Filter> {
+  constructor(protected repository: Repository<T, ID, F>) {}
+
+  search(filter: F, limit: number, page?: number | string,
+        fields?: string[]): Promise<SearchResult<T>> {
+    return this.repository.search(filter, limit, page, fields)
+  }
+
+  load(id: ID): Promise<T | null> {
+    return this.repository.load(id)
+  }
+  create(obj: T): Promise<number> {
+    return this.repository.create(obj)
+  }
+  update(obj: T): Promise<number> {
+    return this.repository.update(obj)
+  }
+  patch(obj: Partial<T>): Promise<number> {
+    return this.repository.patch(obj)
+  }
+  delete(id: ID): Promise<number> {
+    return this.repository.delete(id)
+  }
+}
+```
+
+Applications can extend these classes when the default repository-to-use-case behavior is sufficient, and override methods when additional business logic is required.
+
+## Services and results
+
+Service contracts can be defined independently from the repository layer:
+
+```ts
+export interface SearchService<T, F extends Filter> {
+  search(
+    filter: F,
+    limit: number,
+    page?: number | string,
+    fields?: string[]
+  ): Promise<SearchResult<T>>
+}
+```
+
+CRUD services expose application-facing operations:
+
+```ts
+export interface CRUDService<T, ID> {
+  load(id: ID): Promise<T | null>
+  create(obj: T): Promise<Result<T>>
+  update(obj: T): Promise<Result<T>>
+  patch(obj: Partial<T>): Promise<Result<T>>
+  delete(id: ID): Promise<number>
+}
+```
+
+Validation or application errors can be represented by:
+
+```ts
+export interface ErrorMessage {
+  field: string
+  code: string
+  param?: string | number | Date
+  message?: string
+}
+```
+
+with:
+
+```ts
+export type Result<T> = number | T | ErrorMessage[]
+```
+
+This allows an application layer to return structured field-level errors without coupling the service interface to a particular validation library.
+
+## Ecosystem
+
+`onecore` is intended to be the common foundation for the Core TS packages.
+
+Examples include:
+
+```text
+Database
+├── sql-core
+├── postgres-kit
+├── mysql2-core
+├── oracle-core
+├── mssql-core
+├── cassandra-core 
+└── mongodb-kit
+
+Validation
+└── validation-core
+
+Messaging
+├── message-processing
+├── nats-plus
+├── redis-messaging
+├── rabbitmq-transport
+├── activemq
+├── kafka-plus
+└── ibmmq-plus
+
+Cache
+├── cache-plus
+└── redis-plus
+
+Other
+├── import-service
+├── export-kit
+├── logger-core
+├── health-service
+├── locale-service
+└── web-clients
+```
+
+These packages can share the same contracts and metadata model while remaining independently implemented.
+
+
+## Shared Interfaces
+
+`onecore` defines the common contracts used by the ecosystem.
+
+### Database
 * Statement
-* QueryBuilder
+* DB
+* Transaction
+* SearchRepository
+* CRUDRepository
+* Repository
 
 Implemented by
 
 * sql-core
 * mysql2-core
+* oracle-core
+* mssql-core
 * postgres-kit
+* cassandra-core
 * mongodb-kit
 
----
-
-## Validation
+### Validation
 
 * Validator<T>
 
@@ -222,9 +588,7 @@ Implemented by
 
 * validation-core
 
----
-
-## Cache
+### Cache
 
 * CachePort
 
@@ -233,9 +597,7 @@ Implemented by
 * cache-plus
 * redis-plus
 
----
-
-## Message Queue
+### Message Queue
 
 * Producer
 * Consumer
@@ -248,11 +610,11 @@ Implemented by
 * redis-messaging
 * nats-plus
 * rabbitmq-transport
-* ActiveMQ libraries
-
----
+* activemq
+* kafka-plus
+* ibmmq-plus
 
-## Logging
+### Logging
 
 * Logger
 
@@ -260,9 +622,7 @@ Implemented by
 
 * logger-core
 
----
-
-## Health Check
+### Health Check
 
 * HealthChecker
 
@@ -270,9 +630,7 @@ Implemented by
 
 * health-service
 
----
-
-## HTTP
+### HTTP
 
 * HttpRequest
 * HttpOptionsService
@@ -281,9 +639,7 @@ Implemented by
 
 * web-clients
 
----
-
-## Localization
+### Localization
 
 * Locale
 * Currency
@@ -292,25 +648,42 @@ Implemented by
 
 * locale-service
 
----
+## Zero-cost abstractions
 
-# Reusable Use Cases
+One of the design goals of `onecore` is to provide shared APIs without imposing framework-level runtime overhead.
 
-`onecore` also provides reusable application-layer base classes.
+TypeScript interfaces such as:
 
-Examples include
+```ts
+Repository
+Transaction
+Executor
+Validator
+```
+
+do not exist in the generated JavaScript.
 
-* CRUD services
-* Search services
-* View services
+Reusable classes such as `UseCase` are only included when they are actually imported and used, allowing modern bundlers to tree-shake unused code.
 
-Applications can extend these classes instead of implementing common CRUD logic repeatedly.
+This makes the package suitable for both backend and frontend projects.
 
-Projects that do not use these classes pay no runtime cost.
+## Backend Support
 
----
+Infrastructure services often depend only on interfaces.
+
+Examples include
+
+* Shared metadata
+* Database transactions
+* Repository contracts
+* Application use cases
+* Message Queue services
+* Import services / Export services
+* Infrastructure interfaces: Logging, Cache, Validation...
+
+Since these projects do not use application-layer base classes, the generated JavaScript contains virtually no runtime code from `onecore`.
 
-# Frontend Support
+## Frontend Support
 
 `onecore` works in frontend applications.
 
@@ -323,34 +696,52 @@ React applications commonly use
 
 without importing any backend service classes.
 
+For example:
+
+```ts
+import type {
+  Attribute,
+  Filter,
+  SearchResult
+} from 'onecore'
+```
+
+This allows a frontend and backend to share the same domain metadata and contracts.
+
 The final JavaScript bundle remains minimal because interfaces are removed during compilation and unused code is tree-shaken.
 
----
+## Design principles
 
-# Backend Support
+### One common contract
 
-Infrastructure services often depend only on interfaces.
+Infrastructure implementations should depend on common interfaces instead of forcing applications to depend on implementation details.
 
-Examples include
+### Metadata reuse
 
-* Message Queue services
-* Import services
-* Export services
-* Background workers
+Define metadata once and reuse it across database mapping, validation, search, serialization, import/export, and formatting.
 
-Since these projects do not use application-layer base classes, the generated JavaScript contains virtually no runtime code from `onecore`.
+### Database independence
+
+Application and repository contracts should not expose a PostgreSQL client, MySQL connection, Oracle connection, or other driver-specific resource.
+
+### Explicit transactions
+
+Transactions are passed explicitly to repository operations when multiple operations must participate in the same atomic unit of work.
 
----
+### Minimal runtime
 
-# Sample Projects
+Keep shared contracts in TypeScript interfaces and keep runtime implementations small and reusable.
+
+
+## Sample Projects
 
 The following sample applications demonstrate different ways of using `onecore`.
 
 ### CRUD Applications
 
-* [**sql-modular-sample**](https://github.com/source-code-template/sql-modular-sample) — SQL modular microservice using MySQL
-* [**sql-simple-modular-sample**](https://github.com/source-code-template/sql-simple-modular-sample) — SQL modular microservice using PosgreSQL
-* [**mongo-simple-modular-sample**](https://github.com/source-code-template/mongo-simple-modular-sample) — MongoDB modular microservice
+* [sql-modular-sample](https://github.com/source-code-template/sql-modular-sample) — SQL modular microservice using MySQL
+* [sql-simple-modular-sample](https://github.com/source-code-template/sql-simple-modular-sample) — SQL modular microservice using PosgreSQL
+* [mongo-simple-modular-sample](https://github.com/source-code-template/mongo-simple-modular-sample) — MongoDB modular microservice
 
 These projects extend the reusable CRUD and Search use-case classes.
 
@@ -380,21 +771,8 @@ These projects depend only on interfaces and the shared `Attribute` metadata mod
 
 These projects depend only on interfaces and the shared `Attribute` metadata model.
 
----
-
-# Design Principles
+## License
 
-* Interface-first architecture
-* Dependency inversion
-* Clean Architecture
-* Hexagonal Architecture
-* Tree-shakeable design
-* Shared metadata model
-* Framework independent
-* Enterprise ready
-
----
+MIT
 
-# License
 
-MIT

package/lib/index.js

@@ -0,0 +1,84 @@
+export class SearchUseCase {
+  constructor(repository) {
+    this.repository = repository;
+    this.search = this.search.bind(this);
+  }
+  search(s, limit, page, fields) {
+    return this.repository.search(s, limit, page, fields);
+  }
+}
+export const SearchManager = SearchUseCase;
+export class Writer {
+  constructor(repository) {
+    this.repository = repository;
+    this.create = this.create.bind(this);
+    this.update = this.update.bind(this);
+    this.patch = this.patch.bind(this);
+  }
+  create(obj) {
+    return this.repository.create(obj);
+  }
+  update(obj) {
+    return this.repository.update(obj);
+  }
+  patch(obj) {
+    return (this.repository.patch ? this.repository.patch(obj) : Promise.resolve(-1));
+  }
+}
+export class SearchWriter extends Writer {
+  constructor(repository) {
+    super(repository);
+    this.repository = repository;
+    this.search = this.search.bind(this);
+  }
+  search(filter, limit, page, fields) {
+    return this.repository.search(filter, limit, page, fields);
+  }
+}
+export class UseCase extends SearchWriter {
+  constructor(repository) {
+    super(repository);
+    this.repository = repository;
+    this.metadata = this.metadata.bind(this);
+    this.keys = this.keys.bind(this);
+    this.load = this.load.bind(this);
+    this.delete = this.delete.bind(this);
+  }
+  metadata() {
+    return (this.repository.metadata ? this.repository.metadata() : undefined);
+  }
+  keys() {
+    return (this.repository.keys ? this.repository.keys() : []);
+  }
+  load(id) {
+    return this.repository.load(id);
+  }
+  delete(id) {
+    return this.repository.delete(id);
+  }
+}
+export class CRUDUseCase extends Writer {
+  constructor(repository) {
+    super(repository);
+    this.repository = repository;
+    this.metadata = this.metadata.bind(this);
+    this.keys = this.keys.bind(this);
+    this.load = this.load.bind(this);
+    this.delete = this.delete.bind(this);
+  }
+  metadata() {
+    return (this.repository.metadata ? this.repository.metadata() : undefined);
+  }
+  keys() {
+    return (this.repository.keys ? this.repository.keys() : []);
+  }
+  load(id) {
+    return this.repository.load(id);
+  }
+  delete(id) {
+    return this.repository.delete(id);
+  }
+}
+export const GenericUseCase = CRUDUseCase;
+export const GenericManager = CRUDUseCase;
+export const CRUDManager = CRUDUseCase;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onecore",
-  "version": "0.6.3",
+  "version": "0.6.6",
   "description": "onecore",
   "main": "./lib/index.js",
   "types": "./src/index.ts",

package/src/db.ts

@@ -18,7 +18,7 @@ export interface Executor {
   driver: string
   param(i: number): string
   execute(sql: string, args?: any[]): Promise<number>
-  executeBatch(statements: Statement[], firstSuccess?: boolean): Promise<number>
+  executeBatch(statements: Statement[], requireFirstAffected?: boolean): Promise<number>
   query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T[]>
 }
 export interface Transaction extends Executor {
@@ -35,7 +35,7 @@ export interface ViewRepository<T, ID> {
   load(id: ID, tx?: Transaction): Promise<T | null>;
 }
 export interface SearchRepository<T, F extends Filter> {
-  search(s: F, limit: number, offset?: number|string, fields?: string[], tx?: Transaction): Promise<SearchResult<T>>;
+  search(filter: F, limit: number, offset?: number|string, fields?: string[], tx?: Transaction): Promise<SearchResult<T>>;
 }
 export interface ViewSearchRepository<T, ID, F extends Filter>
   extends ViewRepository<T, ID>, SearchRepository<T, F> {

package/src/formatter.ts

@@ -1,20 +1,19 @@
 export interface Locale {
-  id: string;
-  countryCode: string;
-  dateFormat: string;
-  firstDayOfWeek: number;
-  decimalSeparator: string;
-  groupSeparator: string;
-  decimalDigits: number;
-  currencyCode: string;
-  currencySymbol: string;
-  currencyPattern: number;
-  currencySample?: string;
+  code: string
+  countryCode: string
+  dateFormat: string
+  firstDayOfWeek: number
+  decimalSeparator: string
+  groupSeparator: string
+  decimalDigits: number
+  currencyCode: string
+  currencySymbol: string
+  currencyPattern: number
 }
 export interface Currency {
-  code: string;
-  decimalDigits: number;
-  symbol: string;
+  code: string
+  decimalDigits: number
+  symbol: string
 }
 
 export interface StringFormatter<T> {

package/src/index.ts

@@ -118,11 +118,15 @@ export interface Parser<T> {
 export interface Transformer<T> {
   transform: (data: string) => Promise<T>;
 }
+export interface ExportResult {
+  total: number
+  success: number
+}
 export interface ExportService {
-  export(ctx?: any): Promise<number>;
+  export(ctx?: any): Promise<ExportResult>;
 }
 export interface Exporter {
-  export(ctx?: any): Promise<number>;
+  export(ctx?: any): Promise<ExportResult>;
 }
 
 // tslint:disable-next-line:max-classes-per-file
@@ -171,8 +175,8 @@ export class SearchWriter<T, F extends Filter> extends Writer<T> {
     super(repository)
     this.search = this.search.bind(this);
   }
-  search(s: F, limit: number, page?: number|string, fields?: string[]): Promise<SearchResult<T>> {
-    return this.repository.search(s, limit, page, fields);
+  search(filter: F, limit: number, page?: number|string, fields?: string[]): Promise<SearchResult<T>> {
+    return this.repository.search(filter, limit, page, fields);
   }
 }
 

package/src/io.ts

@@ -27,3 +27,8 @@ export interface ErrorHandler<T> {
 export interface ExceptionHandler<S> {
   handleException(res: S, err: any, i?: number, filename?: string): void
 }
+
+export interface FileWriter<T> {
+  write(chunk: T): boolean
+  end(cb?: () => void): void
+}

package/src/mq.ts

@@ -56,27 +56,27 @@ export interface Writer<T, R, ID> {
 }
 */
 export interface SimpleConsumer<T, R> {
-  consume(handle: (data: T, attributes?: StringMap, raw?: R) => Promise<number>): void;
+  consume(process: (data: T, attributes?: StringMap, raw?: R) => Promise<number>): void;
 }
 export interface SimpleSubscriber<T, R> {
-  subscribe(handle: (data: T, attributes?: StringMap, raw?: R) => Promise<number>): void;
+  subscribe(process: (data: T, attributes?: StringMap, raw?: R) => Promise<number>): void;
 }
 export interface SimpleReceiver<T, R> {
-  receive(handle: (data: T, attributes?: StringMap, raw?: R) => Promise<number>): void;
+  receive(process: (data: T, attributes?: StringMap, raw?: R) => Promise<number>): void;
 }
 export interface SimpleReader<T, R> {
-  read(handle: (data: T, attributes?: StringMap, raw?: R) => Promise<number>): void;
+  read(process: (data: T, attributes?: StringMap, raw?: R) => Promise<number>): void;
 }
 
 export interface MessageConsumer<T, ID, R> {
   consume(data: Message<T, ID, R>): void;
 }
 export interface MessageSubscriber<T, ID, R> {
-  subscribe(handle: (data: Message<T, ID, R>) => Promise<number>): void;
+  subscribe(process: (data: Message<T, ID, R>) => Promise<number>): void;
 }
 export interface MessageReceiver<T, ID, R> {
-  receive(handle: (data: Message<T, ID, R>) => Promise<number>): void;
+  receive(process: (data: Message<T, ID, R>) => Promise<number>): void;
 }
 export interface MessageReader<T, ID, R> {
-  read(handle: (data: Message<T, ID, R>) => Promise<number>): void;
+  read(process: (data: Message<T, ID, R>) => Promise<number>): void;
 }

package/src/service.ts

@@ -9,7 +9,7 @@ export interface ViewService<T, ID> {
 
 export interface SearchService<T, F extends Filter> {
   keys?(): string[];
-  search(s: F, limit: number, page?: number|string, fields?: string[]): Promise<SearchResult<T>>;
+  search(filter: F, limit: number, page?: number|string, fields?: string[]): Promise<SearchResult<T>>;
 }
 
 export interface Query<T, ID, F extends Filter> extends SearchService<T, F> {