@adobe-commerce/aio-toolkit 1.2.0 → 1.2.2

package/CHANGELOG.md

@@ -5,6 +5,148 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.2] - 2026-04-01
+
+### 🐛 Bug Fixes
+
+- **fix(abdb): Fixed `AbdbRepository` update path — `_updated_at` was placed outside `$set`**
+
+  `save(payload, id)` delegated to `updateOne` with `{ $set: payload }` as the payload, but `updateOne` then spread that into `{ $set: payload, _updated_at: now }`. The `_updated_at` key landed at the top level alongside `$set`, making it an invalid MongoDB update document. The `$set` wrapping is now done inside `updateOne` and `update`, so timestamps are always nested correctly.
+
+- **fix(abdb): Fixed `update` method passing an array to `updateMany`**
+
+  `update` (previously `updateAll`) accepted `Array<Partial<T>> | Partial<T>` and always converted the input to an array before passing it as the second argument to `updateMany`. MongoDB's `updateMany` expects a **single** update document, not an array — this caused silent failures at runtime. The method now accepts a single `Partial<T>` and wraps it in `{ $set: ... }`.
+
+- **fix(abdb): Fixed full schema validation on partial update payloads**
+
+  `updateOne` and `update` were calling `this._collection.validate()` (full validation — all required fields must be present) on update payloads. This caused spurious validation errors when patching a subset of fields. Both methods now use `_validatePartial`, which only checks the columns present in the payload.
+
+### ✨ Features
+
+- **feat(abdb): Expanded `AbdbRepository` API with granular single- and bulk-operation methods**
+
+  Five new public methods covering the full MongoDB CRUD surface:
+
+  | New method | Description |
+  |---|---|
+  | `findById(id)` | Shorthand for `findOne({ _id: new ObjectId(id) })` |
+  | `insertOne(payload)` | Single-document insert via `insertOne`; stamps timestamps and validates |
+  | `updateOne(payload, filter?, options?)` | Single-document update via `updateOne` with `$set` wrapping and partial validation |
+  | `deleteOne(filter?)` | Single-document delete via `deleteOne`; returns raw result |
+  | `deleteById(id)` | Shorthand for `deleteOne({ _id: new ObjectId(id) })` |
+
+- **feat(abdb): `save` delegates to `insertOne` / `updateOne`** — eliminates duplicated timestamp-stamping and validation logic.
+
+- **feat(abdb): Split `exists` into `isIdExists` and `exists(filter, options?)`**
+
+  The original `exists(id: string)` only supported lookup by `_id`. It has been renamed to `isIdExists(id)` (preserving the empty-id guard that returns `false` without hitting the DB), and a new general-purpose `exists(filter?, options?)` method has been added that accepts any filter and proxies to `count`.
+
+- **feat(abdb): `count` now accepts an optional `options` parameter**
+
+  `count(filter?, options?)` now forwards `options` to the underlying `countDocuments` call, enabling fine-grained control such as `{ limit: 1 }` for fast existence probes.
+
+### ⚠️ Breaking Changes
+
+- **`exists(id: string)` renamed to `isIdExists(id: string)`**
+
+  `exists` now accepts a general-purpose filter object. Any caller using `repo.exists(someId)` must switch to `repo.isIdExists(someId)`.
+
+- **`delete(id: string)` → `delete(filter: AbdbRepositoryFilter)`**
+
+  `delete` previously accepted a string `_id` and silently no-oped when the id was empty. It now accepts a filter object and uses `deleteMany` under the hood (consistent with `deleteAll`). Use `deleteById(id)` for the old single-by-id behaviour.
+
+- **`insertAll` renamed to `insert`** — identical behaviour, new name aligns with `insertOne`.
+
+- **`updateAll` renamed to `update`** — identical behaviour (plus bug fixes above), new name aligns with `updateOne`.
+
+- **Return types of all mutation methods changed to `Promise<Record<string, any>>`**
+
+  `save`, `insert`, `insertOne`, `update`, `updateOne`, `delete`, `deleteOne`, `deleteById`, and `deleteAll` previously returned `Promise<string>`, `Promise<string[]>`, `Promise<number>`, or `Promise<void>`. All now return the raw MongoDB result document so callers have access to `acknowledged`, `insertedId`, `insertedIds`, `modifiedCount`, `deletedCount`, etc.
+
+### 💡 Migration Guide
+
+```typescript
+// existence check by id — OLD
+const found = await repo.exists(id);
+// existence check by id — NEW
+const found = await repo.isIdExists(id);
+
+// general existence check (new) — by any filter
+const active = await repo.exists({ status: 'active' });
+
+// delete by id — OLD
+await repo.delete(id);
+// delete by id — NEW
+await repo.deleteById(id);
+
+// bulk insert — OLD
+const ids = await repo.insertAll([...]);
+// bulk insert — NEW
+const result = await repo.insert([...]);  // result.insertedIds contains the ids
+
+// bulk update — OLD
+await repo.updateAll({ active: false }, { email: 'bob@example.com' });
+// bulk update — NEW
+await repo.update({ active: false }, { email: 'bob@example.com' });
+
+// return value of save (insert path) — OLD: string _id
+const id = await repo.save({ name: 'Jane', email: 'jane@example.com' });
+// return value of save (insert path) — NEW: raw insertOne result
+const result = await repo.save({ name: 'Jane', email: 'jane@example.com' });
+// result.insertedId contains the new _id
+```
+
+---
+
+## [1.2.1] - 2026-03-31
+
+### ✨ Features
+
+- **feat(abdb): Add `AbdbRepository` — generic CRUD repository for `AbdbCollection`**
+
+  A typed, token-aware repository layer that wraps any `AbdbCollection` and exposes a clean CRUD surface without requiring callers to manage tokens, regions, or raw DB connections per call.
+
+#### `AbdbRepository`
+
+Generic repository class that holds the IMS token and region for its lifetime, auto-stamps `_created_at` / `_updated_at`, and validates every payload against the collection schema before touching the database.
+
+**Single-document operations:**
+
+- `save(payload)` — insert with full schema validation; stamps `_created_at` and `_updated_at`; returns new `_id`
+- `save(payload, id)` — partial update by `_id`; stamps `_updated_at`; only validates fields present in the payload (absent required fields are not re-enforced); returns the same `id`
+- `findOne(filter)` — returns the first document matching an arbitrary filter (e.g. `{ _id: 'x' }` or `{ email: 'a@b.com' }`), or `null`
+- `find(filter?)` — returns all documents matching an optional filter; defaults to all documents
+- `exists(id)` — lightweight existence check via `countDocuments`; returns `boolean`
+- `delete(id)` — deletes by `_id`; no-ops silently for empty id
+- `count(filter?)` — counts matching documents; defaults to all documents
+
+**Bulk operations (single DB round-trip each):**
+
+- `insertAll(payloads[])` — bulk insert via `insertMany`; each payload is stamped and fully validated before the DB call; returns array of inserted ids
+- `updateAll(payload, filter?)` — bulk partial update via `updateMany`; stamps `_updated_at`; partial validation on present fields only
+- `deleteAll(filter?)` — bulk delete via `deleteMany`; defaults to all documents
+
+**Accessors:**
+
+- `getName()` — returns the underlying collection name
+- `getCollection()` — returns the underlying `AbdbCollection` instance
+
+#### Automatic timestamp management
+
+The constructor registers `_created_at` and `_updated_at` columns on the collection exactly once — re-using the same collection across multiple repository instances (e.g. different tokens or regions) is safe.
+
+#### Partial update validation
+
+The update path (`save(payload, id)` and `updateAll`) uses `_validatePartial`, which checks only the columns present in the payload. Required columns that are absent are not re-enforced because they already exist in the stored document. This prevents spurious validation failures when doing field-level patches.
+
+### 📖 Documentation
+
+- **`@adobe/aio-lib-db` declared as required peer dependency** — added to the top-level installation command, peer dependencies table, individual install steps, App Builder `npm list` check command, and ERESOLVE upgrade guide in the README
+- **Database provisioning guide added** — declarative `app.config.yaml` provisioning and `aio app db provision` CLI command documented as step 1 of the `AbdbCollection` usage guide
+- **Authentication guide added** — `generateAccessToken` pattern with `include-ims-credentials` annotation documented as step 2; runtime action example updated to use real token generation instead of a placeholder comment
+- **`AbdbRepository` section added to README** — covers basic usage, automatic timestamps, full API reference tables (single-document and bulk operations), custom region, and bulk operation examples
+- **Fixed `RuntimeApiGatewayService` constructor call** in `test/framework/index.test.ts` — was passing 7 arguments copied from `ImsToken`; corrected to the actual 3-argument signature `(namespace, imsOrgId, imsToken)`
+
 ## [1.2.0] - 2026-03-30
 
 ### ✨ Features

package/README.md

@@ -9,6 +9,7 @@ A comprehensive TypeScript toolkit for Adobe App Builder applications providing
 ```bash
 npm install @adobe-commerce/aio-toolkit \
   @adobe/aio-sdk \
+  @adobe/aio-lib-db \
   @adobe/aio-lib-ims \
   @adobe/aio-lib-telemetry \
   @opentelemetry/resources \
@@ -681,7 +682,58 @@ Typed schema definition and managed database connectivity via `@adobe/aio-lib-db
 
 The recommended pattern is to create a dedicated collection class per entity by extending `AbdbCollection`, then use it directly inside runtime actions.
 
-##### 1. Define a custom collection
+##### 1. Provision a database
+
+A database must be provisioned before any collection can connect. There are two ways to do this:
+
+**Declarative provisioning via `app.config.yaml`** (runs on `aio app deploy`):
+
+```yaml
+application:
+  runtimeManifest:
+    database:
+      auto-provision: true
+      region: emea
+```
+
+When the application is deployed with `aio app deploy`, a database is provisioned in the specified region unless one is already present. Declarative provisioning does **not** run during `aio app run` or `aio app dev`, so the database must be provisioned manually for local development (see below).
+
+**Manual provisioning via the AIO CLI:**
+
+```bash
+aio app db provision [--region <area>]
+```
+
+##### 2. Configure authentication
+
+Every `@adobe/aio-lib-db` call requires an IMS access token. The recommended approach is to use `@adobe/aio-sdk`, which handles token caching and refresh automatically:
+
+```javascript
+const { generateAccessToken } = require('@adobe/aio-sdk').Core.AuthClient;
+const libDb = require('@adobe/aio-lib-db');
+
+async function main(params) {
+  const token = await generateAccessToken(params);
+  const db = await libDb.init({ token: token.access_token });
+}
+```
+
+**Requirements:**
+
+- The AIO project workspace must include the **App Builder Data Services API**.
+- The runtime action must have the `include-ims-credentials` annotation set to `true` in `app.config.yaml`:
+
+```yaml
+actions:
+  action:
+    function: actions/generic/action.js
+    annotations:
+      include-ims-credentials: true
+```
+
+> `@adobe/aio-sdk` transparently manages token caching and refresh — you do not need to implement this yourself.
+
+##### 3. Define a custom collection
 
 Create a reusable collection class that declares the schema once:
 
@@ -712,10 +764,11 @@ class UserCollection extends AbdbCollection {
 module.exports = UserCollection;
 ```
 
-##### 2. Use it in a runtime action
+##### 4. Use it in a runtime action
 
 ```javascript
 const { HttpMethod, RuntimeAction, RuntimeActionResponse } = require('@adobe-commerce/aio-toolkit');
+const { generateAccessToken } = require('@adobe/aio-sdk').Core.AuthClient;
 const UserCollection = require('@lib/UserCollection');
 
 exports.main = RuntimeAction.execute(
@@ -727,7 +780,8 @@ exports.main = RuntimeAction.execute(
     const { first_name, last_name, email } = params;
     const { logger } = ctx;
 
-    const accessToken = /* extract from params / IMS */;
+    const token = await generateAccessToken(params);
+    const accessToken = token.access_token;
 
     const users = new UserCollection();
 
@@ -746,7 +800,7 @@ exports.main = RuntimeAction.execute(
 );
 ```
 
-##### 3. API surface reference
+##### 5. API surface reference
 
 **`addColumn` call forms:**
 
@@ -787,6 +841,119 @@ users.getColumn('email');          // AbdbColumn instance (or undefined)
 users.getColumns();                // Map<string, AbdbColumn> in insertion order
 ```
 
+#### `AbdbRepository`
+
+A generic CRUD repository that wraps an `AbdbCollection` and holds the IMS token and region for the lifetime of the instance. All write methods validate payloads against the collection schema before touching the database, and `_created_at` / `_updated_at` timestamps are stamped automatically.
+
+##### Basic usage
+
+```javascript
+const { AbdbRepository } = require('@adobe-commerce/aio-toolkit');
+const { generateAccessToken } = require('@adobe/aio-sdk').Core.AuthClient;
+const UserCollection = require('@lib/UserCollection');
+
+exports.main = async (params) => {
+  const token = await generateAccessToken(params);
+  const accessToken = token.access_token;
+
+  const repo = new AbdbRepository(new UserCollection(), accessToken);
+
+  // Insert — returns raw insertOne result (result.insertedId contains the new _id)
+  const insertResult = await repo.save({ first_name: 'Jane', last_name: 'Doe', email: 'jane@example.com' });
+  const id = insertResult.insertedId;
+
+  // Read by _id (shorthand)
+  const doc = await repo.findById(id);
+
+  // Read one by any field
+  const byEmail = await repo.findOne({ email: 'jane@example.com' });
+
+  // Read all (optional filter)
+  const all    = await repo.find();
+  const active = await repo.find({ active: true });
+
+  // Partial update — only provided fields are validated; required fields already in the DB are not re-checked
+  await repo.save({ first_name: 'Janet' }, id);
+
+  // Delete by _id
+  await repo.deleteById(id);
+};
+```
+
+##### Automatic timestamps
+
+The repository automatically registers two extra columns on the collection:
+
+| Column | Set on | Value |
+|---|---|---|
+| `_created_at` | First insert only | ISO 8601 UTC string |
+| `_updated_at` | Every insert and update | ISO 8601 UTC string |
+
+These are added once per collection instance, so re-using the same collection across multiple repository instances is safe.
+
+##### API reference
+
+**Single-document operations:**
+
+| Method | Description | Returns |
+|---|---|---|
+| `save(payload)` | Insert via `insertOne` (full validation, stamps both timestamps) | `Promise<Record<string, any>>` — raw `insertOne` result |
+| `save(payload, id)` | Update via `updateOne` with `upsert: true` (partial validation, stamps `_updated_at`) | `Promise<Record<string, any>>` — raw `updateOne` result |
+| `insertOne(payload)` | Single-document insert (full validation, stamps both timestamps) | `Promise<Record<string, any>>` — raw `insertOne` result (e.g. `insertedId`) |
+| `updateOne(payload, filter?, options?)` | Single-document update via `{ $set: payload }` (partial validation, stamps `_updated_at`) | `Promise<Record<string, any>>` — raw `updateOne` result (e.g. `modifiedCount`) |
+| `findOne(filter)` | First document matching filter, e.g. `{ email: 'a@b.com' }` | `Promise<T \| null>` |
+| `findById(id)` | Shorthand for `findOne({ _id: new ObjectId(id) })` | `Promise<T \| null>` |
+| `find(filter?)` | All documents matching filter (default: all) | `Promise<T[]>` |
+| `isIdExists(id)` | Returns `true` if a document with the given `_id` exists (no-op for empty id) | `Promise<boolean>` |
+| `exists(filter?, options?)` | Returns `true` if any document matching `filter` exists via `countDocuments` | `Promise<boolean>` |
+| `deleteOne(filter?)` | Delete first matching document via `deleteOne` | `Promise<Record<string, any>>` — raw `deleteOne` result |
+| `deleteById(id)` | Shorthand for `deleteOne({ _id: new ObjectId(id) })` | `Promise<Record<string, any>>` |
+| `count(filter?, options?)` | Count matching documents via `countDocuments` (default: all) | `Promise<number>` |
+
+**Bulk operations (single DB round-trip each):**
+
+| Method | Description | Returns |
+|---|---|---|
+| `insert(payloads[])` | Bulk insert via `insertMany` — each payload stamped and validated | `Promise<Record<string, any>>` — raw `insertMany` result (e.g. `insertedIds`) |
+| `update(payload, filter?, options?)` | Bulk update via `updateMany` with `{ $set: payload }` — stamps `_updated_at`, partial validation | `Promise<Record<string, any>>` — raw `updateMany` result (e.g. `modifiedCount`) |
+| `delete(filter?)` | Bulk delete via `deleteMany` (default: all documents) | `Promise<Record<string, any>>` — raw `deleteMany` result (e.g. `deletedCount`) |
+
+**Accessors:**
+
+| Method | Description |
+|---|---|
+| `getName()` | Returns the underlying collection name |
+| `getCollection()` | Returns the underlying `AbdbCollection` instance |
+
+##### Custom region
+
+```javascript
+// Default region is 'amer'. Pass a third argument to override:
+const repo = new AbdbRepository(new UserCollection(), accessToken, 'emea');
+```
+
+##### Bulk operations
+
+```javascript
+// Insert multiple documents in one DB call
+const result = await repo.insert([
+  { first_name: 'Alice', last_name: 'Smith', email: 'alice@example.com' },
+  { first_name: 'Bob',   last_name: 'Jones', email: 'bob@example.com'   },
+]);
+console.log(result.insertedIds); // array of inserted _id values
+
+// Update all matching documents in one DB call
+const updateResult = await repo.update({ active: false }, { email: 'bob@example.com' });
+console.log(updateResult.modifiedCount); // number of documents updated
+
+// Delete all matching documents in one DB call
+const deleteResult = await repo.delete({ active: false });
+console.log(deleteResult.deletedCount); // number of documents deleted
+
+// Delete everything in the collection
+await repo.delete();
+```
+
 ### 🏪 Commerce Components  
 
 **Adobe Commerce API integration and authentication**
@@ -1892,12 +2059,13 @@ Packages that maintain **singleton state or shared registries** — if two copie
 | Package | Why it must be shared |
 |---|---|
 | `@adobe/aio-sdk` | Singleton services — logger, config, state are shared across the app |
+| `@adobe/aio-lib-db` | Database client singleton — connection state and collection registry must be shared |
 | `graphql` | Schema registry is a singleton — `instanceof GraphQLSchema` and type checks fail with two copies |
 | `@adobe/aio-lib-ims` | Token cache and auth context must be the same shared instance |
 | `@adobe/aio-lib-telemetry` | Single telemetry pipeline — two copies split traces and logs |
 | `@opentelemetry/resources` | Resource object tied to the telemetry pipeline instance |
 
-All five are **required** — they are unconditionally imported when the package loads (`export * from './framework'` and `export * from './commerce'` in the root `index.ts`). If any is missing, the entire package will fail to load with a `Cannot find module` error.
+All six are **required** — they are unconditionally imported when the package loads (`export * from './framework'` and `export * from './commerce'` in the root `index.ts`). If any is missing, the entire package will fail to load with a `Cannot find module` error.
 
 ### Installing peer dependencies
 
@@ -1906,6 +2074,7 @@ Install the toolkit and all required peer dependencies in one command:
 ```bash
 npm install @adobe-commerce/aio-toolkit \
   @adobe/aio-sdk \
+  @adobe/aio-lib-db \
   @adobe/aio-lib-ims \
   @adobe/aio-lib-telemetry \
   @opentelemetry/resources \
@@ -1918,14 +2087,15 @@ Or individually if you prefer to control versions:
 npm install @adobe-commerce/aio-toolkit
 
 # Required peer dependencies
-npm install @adobe/aio-sdk@^5.0.0
+npm install @adobe/aio-sdk@^6.0.0
+npm install @adobe/aio-lib-db@^1.0.0
 npm install @adobe/aio-lib-ims@^7.0.0
 npm install @adobe/aio-lib-telemetry@^1.0.0
 npm install @opentelemetry/resources@^2.0.0
 npm install graphql@^16.0.0
 ```
 
-> **Note for App Builder projects:** `@adobe/aio-sdk`, `graphql`, and `@adobe/aio-lib-ims` are almost always already present in a standard App Builder project. Run `npm list @adobe/aio-sdk graphql @adobe/aio-lib-ims` to check before installing.
+> **Note for App Builder projects:** `@adobe/aio-sdk`, `graphql`, and `@adobe/aio-lib-ims` are almost always already present in a standard App Builder project. Run `npm list @adobe/aio-sdk @adobe/aio-lib-db graphql @adobe/aio-lib-ims` to check before installing.
 
 ### Resolving `ERESOLVE` errors
 
@@ -1940,9 +2110,12 @@ npm install @adobe-commerce/aio-toolkit 2>&1 | grep "Found:"
 **Upgrade the conflicting package to a compatible version:**
 
 ```bash
-# @adobe/aio-sdk must be >=5.0.0
+# @adobe/aio-sdk must be >=6.0.0
 npm install @adobe/aio-sdk@latest
 
+# @adobe/aio-lib-db must be >=1.0.0
+npm install @adobe/aio-lib-db@latest
+
 # graphql must be >=14.0.0
 npm install graphql@latest
 

package/dist/index.d.mts

@@ -203,6 +203,99 @@ declare class FileRepository {
     private getFiles;
 }
 
+declare enum AbdbColumnType {
+    STRING = "STRING",
+    NUMBER = "NUMBER",
+    BOOLEAN = "BOOLEAN",
+    DATETIME = "DATETIME"
+}
+interface AbdbColumnOptions {
+    name: string;
+    type: AbdbColumnType;
+    description?: string;
+    isRequired?: boolean;
+}
+interface AbdbColumnJson {
+    name: string;
+    type: AbdbColumnType;
+    description?: string;
+    isRequired?: true;
+}
+
+declare class AbdbColumn {
+    private readonly _name;
+    private readonly _type;
+    private readonly _description;
+    private readonly _isRequired;
+    constructor(options: AbdbColumnOptions);
+    getName(): string;
+    getType(): AbdbColumnType;
+    getDescription(): string | undefined;
+    getIsRequired(): boolean;
+    toJSON(): AbdbColumnJson;
+    clone(overrides?: Partial<AbdbColumnOptions>): AbdbColumn;
+    validate(value: unknown): void;
+    private _isMissingValue;
+    private _validateStringValue;
+    private _validateNumberValue;
+    private _validateBooleanValue;
+    private _validateDateTimeValue;
+}
+
+type AddColumnOptions = Omit<AbdbColumnOptions, 'name' | 'type'>;
+type AbdbRunCallback<T = unknown> = (collection: DbCollection, client: DbClient) => Promise<T>;
+
+type AbdbCollectionCallback = (collection: AbdbCollection) => void;
+declare class AbdbCollection {
+    private readonly _name;
+    private readonly _columns;
+    constructor(name: string, callback?: AbdbCollectionCallback);
+    getName(): string;
+    addColumn(name: string, type: AbdbColumnType, options?: AddColumnOptions): this;
+    addColumn(name: string, type: AbdbColumnType, description?: string, isRequired?: boolean): this;
+    getColumns(): AbdbColumn[];
+    getColumn(name: string): AbdbColumn | undefined;
+    hasColumn(name: string): boolean;
+    validate(record: Record<string, unknown>): void;
+    validateAll(record: Record<string, unknown>): string[];
+    run<T>(callback: AbdbRunCallback<T>, token: string, region?: string): Promise<T>;
+    private _validateCollectionName;
+    private _validateColumnName;
+    private _validateIdentifier;
+}
+
+interface AbdbRecord {
+    _id?: string;
+    _created_at?: string;
+    _updated_at?: string;
+    [key: string]: unknown;
+}
+type AbdbRepositoryFilter = Record<string, unknown>;
+
+declare class AbdbRepository<T extends AbdbRecord = AbdbRecord> {
+    private readonly _collection;
+    private readonly _token;
+    private readonly _region;
+    constructor(collection: AbdbCollection, token: string, region?: string);
+    getName(): string;
+    getCollection(): AbdbCollection;
+    find(filter?: AbdbRepositoryFilter): Promise<T[]>;
+    findOne(filter: AbdbRepositoryFilter): Promise<T | null>;
+    findById(id: string): Promise<T | null>;
+    delete(filter?: AbdbRepositoryFilter): Promise<Record<string, any>>;
+    deleteOne(filter?: AbdbRepositoryFilter): Promise<Record<string, any>>;
+    deleteById(id: string): Promise<Record<string, any>>;
+    insert(payloads: Array<Partial<T>>): Promise<Record<string, any>>;
+    insertOne(payload: Partial<T>): Promise<Record<string, any>>;
+    update(payload: Partial<T>, filter?: AbdbRepositoryFilter, options?: Record<string, any>): Promise<Record<string, any>>;
+    updateOne(payload: Partial<T>, filter?: AbdbRepositoryFilter, options?: Record<string, any>): Promise<Record<string, any>>;
+    save(payload?: Partial<T>, id?: string): Promise<Record<string, any>>;
+    isIdExists(id: string): Promise<boolean>;
+    exists(filter?: AbdbRepositoryFilter, options?: Record<string, any>): Promise<boolean>;
+    count(filter?: AbdbRepositoryFilter, options?: Record<string, any>): Promise<number>;
+    private _validatePartial;
+}
+
 interface EventData {
     type: string;
     data: any;
@@ -328,67 +421,6 @@ declare class RuntimeApiGatewayService {
     delete(endpoint: string, additionalHeaders?: Record<string, string>): Promise<any>;
 }
 
-declare enum AbdbColumnType {
-    STRING = "STRING",
-    NUMBER = "NUMBER",
-    BOOLEAN = "BOOLEAN",
-    DATETIME = "DATETIME"
-}
-interface AbdbColumnOptions {
-    name: string;
-    type: AbdbColumnType;
-    description?: string;
-    isRequired?: boolean;
-}
-interface AbdbColumnJson {
-    name: string;
-    type: AbdbColumnType;
-    description?: string;
-    isRequired?: true;
-}
-
-declare class AbdbColumn {
-    private readonly _name;
-    private readonly _type;
-    private readonly _description;
-    private readonly _isRequired;
-    constructor(options: AbdbColumnOptions);
-    getName(): string;
-    getType(): AbdbColumnType;
-    getDescription(): string | undefined;
-    getIsRequired(): boolean;
-    toJSON(): AbdbColumnJson;
-    clone(overrides?: Partial<AbdbColumnOptions>): AbdbColumn;
-    validate(value: unknown): void;
-    private _isMissingValue;
-    private _validateStringValue;
-    private _validateNumberValue;
-    private _validateBooleanValue;
-    private _validateDateTimeValue;
-}
-
-type AddColumnOptions = Omit<AbdbColumnOptions, 'name' | 'type'>;
-type AbdbRunCallback<T = unknown> = (collection: DbCollection, client: DbClient) => Promise<T>;
-
-type AbdbCollectionCallback = (collection: AbdbCollection) => void;
-declare class AbdbCollection {
-    private readonly _name;
-    private readonly _columns;
-    constructor(name: string, callback?: AbdbCollectionCallback);
-    getName(): string;
-    addColumn(name: string, type: AbdbColumnType, options?: AddColumnOptions): this;
-    addColumn(name: string, type: AbdbColumnType, description?: string, isRequired?: boolean): this;
-    getColumns(): AbdbColumn[];
-    getColumn(name: string): AbdbColumn | undefined;
-    hasColumn(name: string): boolean;
-    validate(record: Record<string, unknown>): void;
-    validateAll(record: Record<string, unknown>): string[];
-    run<T>(callback: AbdbRunCallback<T>, token: string, region?: string): Promise<T>;
-    private _validateCollectionName;
-    private _validateColumnName;
-    private _validateIdentifier;
-}
-
 declare class TelemetryInputError extends Error {
     constructor(message: string);
 }
@@ -1051,4 +1083,4 @@ declare class AdminUiSdk {
     getRegistration(): AdminUiSdkRegistration;
 }
 
-export { AbdbCollection, type AbdbCollectionCallback, AbdbColumn, type AbdbColumnJson, type AbdbColumnOptions, AbdbColumnType, type AbdbRunCallback, type AddColumnOptions, AdminUiSdk, type AdminUiSdkRegistration, AdobeAuth, AdobeCommerceClient, type AdobeIMSConfig, type BaseTelemetry, type BaseTelemetryValidator, BasicAuthConnection, BearerToken, type BearerTokenInfo, type CommerceEvent, type CommerceEventConfig, type CommerceEventField, type Connection, type CreateEventResult, CreateEvents, type CreateProviderParams, type CreateProviderResult, type CreateRegistrationResult, CreateRegistrations, type ErrorResponse, EventConsumerAction, type EventData, type EventMetadata, type EventMetadataInputModel, type EventMetadataListResponse, EventMetadataManager, type ExtendedRequestError, type FileMetadata, type FileRecord, FileRepository, GenerateBasicAuthToken, type GetProviderQueryParams, type GetRegistrationQueryParams, GraphQlAction, type HALLink, type Headers, HttpMethod, HttpStatus, IOEventsApiError, type IOEventsError, ImsConnection, ImsToken, type ImsTokenResult, InfiniteLoopBreaker, type InfiniteLoopData, IoEventsGlobals, JsonMessageProcessor, type ListProvidersQueryParams, type ListRegistrationQueryParams, type MenuItem, Oauth1aConnection, OnboardCommerce, type OnboardCommerceConfig, type OnboardCommerceResult, OnboardEvents, type OnboardEventsInput, type OnboardEventsResponse, OnboardEvents as OnboardIOEvents, Openwhisk, OpenwhiskAction, type OpenwhiskConfig, type Page, Parameters, type Provider, type ProviderInputModel, ProviderManager, PublishEvent, type PublishEventResult, type Registration, type RegistrationCreateModel, type RegistrationListResponse, RegistrationManager, RestClient, RuntimeAction, RuntimeActionResponse, type RuntimeActionResponseType, RuntimeApiGatewayService, ShippingCarrier, type ShippingCarrierData, ShippingCarrierMethod, type ShippingCarrierMethodAdditionalData, type ShippingCarrierMethodData, ShippingCarrierResponse, SignatureVerification, SuccessChecker, type SuccessResponse, Telemetry, TelemetryInputError, type TokenResult, Validator, WebhookAction, type WebhookActionAddResponse, type WebhookActionExceptionResponse, WebhookActionOperation, type WebhookActionRemoveResponse, type WebhookActionReplaceResponse, WebhookActionResponse, type WebhookActionResponseType, type WebhookActionSuccessResponse, type WorkspaceConfig };
+export { AbdbCollection, type AbdbCollectionCallback, AbdbColumn, type AbdbColumnJson, type AbdbColumnOptions, AbdbColumnType, type AbdbRecord, AbdbRepository, type AbdbRepositoryFilter, type AbdbRunCallback, type AddColumnOptions, AdminUiSdk, type AdminUiSdkRegistration, AdobeAuth, AdobeCommerceClient, type AdobeIMSConfig, type BaseTelemetry, type BaseTelemetryValidator, BasicAuthConnection, BearerToken, type BearerTokenInfo, type CommerceEvent, type CommerceEventConfig, type CommerceEventField, type Connection, type CreateEventResult, CreateEvents, type CreateProviderParams, type CreateProviderResult, type CreateRegistrationResult, CreateRegistrations, type ErrorResponse, EventConsumerAction, type EventData, type EventMetadata, type EventMetadataInputModel, type EventMetadataListResponse, EventMetadataManager, type ExtendedRequestError, type FileMetadata, type FileRecord, FileRepository, GenerateBasicAuthToken, type GetProviderQueryParams, type GetRegistrationQueryParams, GraphQlAction, type HALLink, type Headers, HttpMethod, HttpStatus, IOEventsApiError, type IOEventsError, ImsConnection, ImsToken, type ImsTokenResult, InfiniteLoopBreaker, type InfiniteLoopData, IoEventsGlobals, JsonMessageProcessor, type ListProvidersQueryParams, type ListRegistrationQueryParams, type MenuItem, Oauth1aConnection, OnboardCommerce, type OnboardCommerceConfig, type OnboardCommerceResult, OnboardEvents, type OnboardEventsInput, type OnboardEventsResponse, OnboardEvents as OnboardIOEvents, Openwhisk, OpenwhiskAction, type OpenwhiskConfig, type Page, Parameters, type Provider, type ProviderInputModel, ProviderManager, PublishEvent, type PublishEventResult, type Registration, type RegistrationCreateModel, type RegistrationListResponse, RegistrationManager, RestClient, RuntimeAction, RuntimeActionResponse, type RuntimeActionResponseType, RuntimeApiGatewayService, ShippingCarrier, type ShippingCarrierData, ShippingCarrierMethod, type ShippingCarrierMethodAdditionalData, type ShippingCarrierMethodData, ShippingCarrierResponse, SignatureVerification, SuccessChecker, type SuccessResponse, Telemetry, TelemetryInputError, type TokenResult, Validator, WebhookAction, type WebhookActionAddResponse, type WebhookActionExceptionResponse, WebhookActionOperation, type WebhookActionRemoveResponse, type WebhookActionReplaceResponse, WebhookActionResponse, type WebhookActionResponseType, type WebhookActionSuccessResponse, type WorkspaceConfig };