onecore 0.6.3 → 0.6.5

package/README.md

@@ -4,34 +4,17 @@
 
 `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
@@ -39,108 +22,102 @@ For example:
 * 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.
-
----
+* HTTP clients
+* Import / Export
+* 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        │
+                    │  Repository       │
+                    │  Transaction      │
+                    │  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
+* Database executor and transaction abstractions
+* Repository abstractions for CRUD and search
+* Reusable CRUD and Search use-case classes
+* Generic filtering and search result models
+* Type-safe database parameter abstraction
+* No framework dependency
+* Interfaces with no runtime representation after TypeScript compilation
+* Suitable for both backend and frontend projects
+* Tree-shakeable runtime code
 
-## Interfaces
+## 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.
+Unlike persistence-specific or validation-specific metadata, `Attribute` is the canonical metadata model shared across the entire ecosystem.
 
-Modern bundlers such as Webpack, Rollup, Vite, and esbuild tree-shake unused code automatically.
+`Attribute` is intended to be shared by multiple parts of an application instead of maintaining separate metadata definitions for every subsystem.
 
-This allows frontend and backend projects to share the same package while keeping bundles minimal.
+For example, the same metadata can describe:
 
----
-
-# Unified Metadata
+* Database mapping
+* Validation
+* Search
+* Formatting
+* Import
+* Export
+* Serialization
 
-The most important type in `onecore` is `Attribute`.
-
-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
@@ -151,7 +128,10 @@ Unlike persistence-specific or validation-specific metadata, `Attribute` is the
       │               │                │
 validation-core   sql-core        import-service
                  mysql2-core        export-kit
+                 mssql-core
+                 oracle-core
                  postgres-kit
+                 cassandra-core
                  mongodb-kit
 ```
 
@@ -190,17 +170,397 @@ 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
+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
+  execute(sql: string, args?: any[]): Promise<number>
+  executeBatch(statements: Statement[], requireFirstAffected?: boolean): Promise<number>
+  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T[]>
+}
+```
+
+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.
+
+### CRUD
+
+```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)
+```
+
+### Search
+
+```ts
+export interface SearchRepository<T, F extends Filter> {
+  search(
+    s: 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.
+
+## Combined repositories
+
+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)
+  }
+}
+```
+
+### Combined 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
+├── mysql2-core
+├── postgres-kit
+├── oracle-core
+├── mssql-core
+└── mongodb-kit
+
+Validation
+└── validation-core
+
+Messaging
+├── message-processing
+├── nats-plus
+├── redis-messaging
+├── rabbitmq-transport
+├── activemq
+└── ibmmq-plus
+
+Cache
+├── cache-plus
+└── redis-plus
+
+Other
+├── logger-core
+├── health-service
+├── web-clients
+├── locale-service
+├── import-service
+└── export-kit
+```
+
+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
 * SearchRepository
+* CRUDRepository
+* Repository
 * Transaction
 * Statement
 * QueryBuilder
@@ -209,12 +569,15 @@ Implemented by
 
 * sql-core
 * mysql2-core
+* oracle-core
+* mssql-core
 * postgres-kit
+* cassandra-core
 * mongodb-kit
 
 ---
 
-## Validation
+### Validation
 
 * Validator<T>
 
@@ -224,7 +587,7 @@ Implemented by
 
 ---
 
-## Cache
+### Cache
 
 * CachePort
 
@@ -235,7 +598,7 @@ Implemented by
 
 ---
 
-## Message Queue
+### Message Queue
 
 * Producer
 * Consumer
@@ -252,7 +615,7 @@ Implemented by
 
 ---
 
-## Logging
+### Logging
 
 * Logger
 
@@ -262,7 +625,7 @@ Implemented by
 
 ---
 
-## Health Check
+### Health Check
 
 * HealthChecker
 
@@ -272,7 +635,7 @@ Implemented by
 
 ---
 
-## HTTP
+### HTTP
 
 * HttpRequest
 * HttpOptionsService
@@ -283,7 +646,7 @@ Implemented by
 
 ---
 
-## Localization
+### Localization
 
 * Locale
 * Currency
@@ -292,23 +655,74 @@ 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
+```
 
-* CRUD services
-* Search services
-* View services
+do not exist in the generated JavaScript.
 
-Applications can extend these classes instead of implementing common CRUD logic repeatedly.
+Reusable classes such as `UseCase` are only included when they are actually imported and used, allowing modern bundlers to tree-shake unused code.
 
-Projects that do not use these classes pay no runtime cost.
+This makes the package suitable for both backend and frontend projects.
 
----
+## Backend and frontend
+
+Backend applications can use `onecore` for:
+
+* Repository contracts
+* Database transactions
+* Shared metadata
+* Application use cases
+* Infrastructure interfaces
+
+Frontend applications can use shared models and metadata without needing to import backend implementations.
+
+For example:
+
+```ts
+import type {
+  Attribute,
+  Filter,
+  SearchResult
+} from 'onecore'
+```
+
+This allows a frontend and backend to share the same domain metadata and contracts.
+
+## Design principles
+
+### One common contract
+
+Infrastructure implementations should depend on common interfaces instead of forcing applications to depend on implementation details.
+
+### Metadata reuse
+
+Define metadata once and reuse it across database mapping, validation, search, serialization, import/export, and formatting.
+
+### 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
+
+Keep shared contracts in TypeScript interfaces and keep runtime implementations small and reusable.
+
+## License
+
+MIT
 
 # Frontend Support
 

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.5",
   "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

@@ -171,8 +171,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/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> {