@decaf-ts/for-http 0.8.0 → 0.9.0

package/lib/types/RestRepository.d.cts

@@ -0,0 +1,63 @@
+import { DirectionLimitOffset, OrderDirection, Repository } from "@decaf-ts/core";
+import type { ContextOf, MaybeContextualArg, SerializedPage } from "@decaf-ts/core";
+import { Model } from "@decaf-ts/decorator-validation";
+import { Constructor } from "@decaf-ts/decoration";
+import { HttpAdapter } from "./adapter.cjs";
+/**
+ * @description Repository for REST API interactions
+ * @summary A specialized repository implementation for interacting with REST APIs.
+ * This class extends the core Repository class and works with HTTP adapters to
+ * provide CRUD operations for models via REST endpoints.
+ * This Is NOT the default repository for the HTTP adapter. That would be {@link RestService}.
+ * Use this only in the specific case of needing to run the CURD model logic (decoration) before submitting to the backend
+ * @template M - The model type, extending Model
+ * @template Q - The query type used by the adapter
+ * @template A - The HTTP adapter type, extending HttpAdapter
+ * @template F - The HTTP flags type, extending HttpFlags
+ * @template C - The context type, extending Context<F>
+ * @param {A} adapter - The HTTP adapter instance
+ * @param {Constructor<M>} [clazz] - Optional constructor for the model class
+ * @class RestRepository
+ * @example
+ * ```typescript
+ * // Create a repository for User model with Axios adapter
+ * const axiosAdapter = new AxiosAdapter({
+ *   protocol: 'https',
+ *   host: 'api.example.com'
+ * });
+ * const userRepository = new RestRepository(axiosAdapter, User);
+ *
+ * // Use the repository for CRUD operations
+ * const user = await userRepository.findById('123');
+ * ```
+ * @see {@link RestService}
+ */
+export declare class RestRepository<M extends Model, A extends HttpAdapter<any, any, any, any, any>, Q = A extends HttpAdapter<any, any, any, infer Q, any> ? Q : never> extends Repository<M, A> {
+    protected _overrides: Partial<import("@decaf-ts/core").FlagsOf<ContextOf<A>>> & {
+        allowRawStatements: boolean;
+        forcePrepareSimpleQueries: boolean;
+        forcePrepareComplexQueries: boolean;
+    };
+    constructor(adapter: A, clazz?: Constructor<M>);
+    url<M extends Model>(tableName: string | Constructor<M>): string;
+    url<M extends Model>(tableName: string | Constructor<M>, pathParams: string[]): string;
+    url<M extends Model>(tableName: string | Constructor<M>, queryParams: Record<string, string | number> | undefined): string;
+    paginateBy(key: keyof M, order: OrderDirection, ref?: Omit<DirectionLimitOffset, "direction">, ...args: MaybeContextualArg<ContextOf<A>>): Promise<SerializedPage<M>>;
+    listBy(key: keyof M, order: OrderDirection, ...args: MaybeContextualArg<ContextOf<A>>): Promise<any>;
+    findBy(key: keyof M, value: any, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    findOneBy(key: keyof M, value: any, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
+    find(value: string, order?: OrderDirection, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    page(value: string, direction?: OrderDirection, ref?: Omit<DirectionLimitOffset, "direction">, ...args: MaybeContextualArg<ContextOf<A>>): Promise<SerializedPage<M>>;
+    statement(name: string, ...args: MaybeContextualArg<ContextOf<A>>): Promise<any>;
+    private convertStatementResult;
+    private convertPageResult;
+    private revertRecord;
+    request<R>(details: Q, ...args: MaybeContextualArg<ContextOf<A>>): Promise<R>;
+    countOf(key?: keyof M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<number>;
+    maxOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[K]>;
+    minOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[K]>;
+    avgOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<number>;
+    sumOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<number>;
+    distinctOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[K][]>;
+    groupOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<Record<string, M[]>>;
+}

package/lib/types/RestRepository.d.mts

@@ -0,0 +1,63 @@
+import { DirectionLimitOffset, OrderDirection, Repository } from "@decaf-ts/core";
+import type { ContextOf, MaybeContextualArg, SerializedPage } from "@decaf-ts/core";
+import { Model } from "@decaf-ts/decorator-validation";
+import { Constructor } from "@decaf-ts/decoration";
+import { HttpAdapter } from "./adapter.js";
+/**
+ * @description Repository for REST API interactions
+ * @summary A specialized repository implementation for interacting with REST APIs.
+ * This class extends the core Repository class and works with HTTP adapters to
+ * provide CRUD operations for models via REST endpoints.
+ * This Is NOT the default repository for the HTTP adapter. That would be {@link RestService}.
+ * Use this only in the specific case of needing to run the CURD model logic (decoration) before submitting to the backend
+ * @template M - The model type, extending Model
+ * @template Q - The query type used by the adapter
+ * @template A - The HTTP adapter type, extending HttpAdapter
+ * @template F - The HTTP flags type, extending HttpFlags
+ * @template C - The context type, extending Context<F>
+ * @param {A} adapter - The HTTP adapter instance
+ * @param {Constructor<M>} [clazz] - Optional constructor for the model class
+ * @class RestRepository
+ * @example
+ * ```typescript
+ * // Create a repository for User model with Axios adapter
+ * const axiosAdapter = new AxiosAdapter({
+ *   protocol: 'https',
+ *   host: 'api.example.com'
+ * });
+ * const userRepository = new RestRepository(axiosAdapter, User);
+ *
+ * // Use the repository for CRUD operations
+ * const user = await userRepository.findById('123');
+ * ```
+ * @see {@link RestService}
+ */
+export declare class RestRepository<M extends Model, A extends HttpAdapter<any, any, any, any, any>, Q = A extends HttpAdapter<any, any, any, infer Q, any> ? Q : never> extends Repository<M, A> {
+    protected _overrides: Partial<import("@decaf-ts/core").FlagsOf<ContextOf<A>>> & {
+        allowRawStatements: boolean;
+        forcePrepareSimpleQueries: boolean;
+        forcePrepareComplexQueries: boolean;
+    };
+    constructor(adapter: A, clazz?: Constructor<M>);
+    url<M extends Model>(tableName: string | Constructor<M>): string;
+    url<M extends Model>(tableName: string | Constructor<M>, pathParams: string[]): string;
+    url<M extends Model>(tableName: string | Constructor<M>, queryParams: Record<string, string | number> | undefined): string;
+    paginateBy(key: keyof M, order: OrderDirection, ref?: Omit<DirectionLimitOffset, "direction">, ...args: MaybeContextualArg<ContextOf<A>>): Promise<SerializedPage<M>>;
+    listBy(key: keyof M, order: OrderDirection, ...args: MaybeContextualArg<ContextOf<A>>): Promise<any>;
+    findBy(key: keyof M, value: any, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    findOneBy(key: keyof M, value: any, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
+    find(value: string, order?: OrderDirection, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    page(value: string, direction?: OrderDirection, ref?: Omit<DirectionLimitOffset, "direction">, ...args: MaybeContextualArg<ContextOf<A>>): Promise<SerializedPage<M>>;
+    statement(name: string, ...args: MaybeContextualArg<ContextOf<A>>): Promise<any>;
+    private convertStatementResult;
+    private convertPageResult;
+    private revertRecord;
+    request<R>(details: Q, ...args: MaybeContextualArg<ContextOf<A>>): Promise<R>;
+    countOf(key?: keyof M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<number>;
+    maxOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[K]>;
+    minOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[K]>;
+    avgOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<number>;
+    sumOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<number>;
+    distinctOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[K][]>;
+    groupOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<Record<string, M[]>>;
+}

package/lib/types/RestService.d.cts

@@ -0,0 +1,74 @@
+import { Model } from "@decaf-ts/decorator-validation";
+import { Constructor } from "@decaf-ts/decoration";
+import { HttpAdapter } from "./adapter.cjs";
+import { RestRepository } from "./RestRepository.cjs";
+/**
+ * @description Service class for REST API operations
+ * @summary Provides a comprehensive implementation for interacting with REST APIs.
+ * This class implements CRUD operations for single and bulk operations, as well as
+ * the Observable pattern to notify observers of changes. It works with HTTP adapters
+ * to perform the actual API requests and handles model conversion.
+ * @template M - The model type, extending Model
+ * @template Q - The query type used by the adapter
+ * @template A - The HTTP adapter type, extending HttpAdapter
+ * @template F - The HTTP flags type, extending HttpFlags
+ * @template C - The context type, extending Context<F>
+ * @param {A} adapter - The HTTP adapter instance
+ * @param {Constructor<M>} [clazz] - Optional constructor for the model class
+ * @class RestService
+ * @example
+ * ```typescript
+ * // Create a service for User model with Axios adapter
+ * const axiosAdapter = new AxiosAdapter({
+ *   protocol: 'https',
+ *   host: 'api.example.com'
+ * });
+ * const userService = new RestService(axiosAdapter, User);
+ *
+ * // Create a new user
+ * const user = new User({ name: 'John Doe', email: 'john@example.com' });
+ * const createdUser = await userService.create(user);
+ *
+ * // Update a user
+ * createdUser.name = 'Jane Doe';
+ * const updatedUser = await userService.update(createdUser);
+ *
+ * // Delete a user
+ * await userService.delete(updatedUser.id);
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Service as RestService
+ *   participant Adapter as HttpAdapter
+ *   participant API
+ *   Client->>Service: create(model)
+ *   Service->>Adapter: prepare(model, pk)
+ *   Service->>Adapter: create(table, id, record)
+ *   Adapter->>API: HTTP POST
+ *   API-->>Adapter: 201 Created
+ *   Adapter-->>Service: record
+ *   Service-->>Client: revert(record)
+ */
+export declare class RestService<M extends Model, A extends HttpAdapter<any, any, any, any, any>, Q = A extends HttpAdapter<any, any, any, infer Q, any> ? Q : never> extends RestRepository<M, A, Q> {
+    protected _overrides: Partial<import("@decaf-ts/core").FlagsOf<import("@decaf-ts/core").ContextOf<A>>> & {
+        allowRawStatements: boolean;
+        forcePrepareSimpleQueries: boolean;
+        forcePrepareComplexQueries: boolean;
+    } & {
+        ignoreValidation: boolean;
+        ignoreHandlers: boolean;
+        allowRawStatements: boolean;
+        forcePrepareSimpleQueries: boolean;
+        forcePrepareComplexQueries: boolean;
+    };
+    /**
+     * @description Initializes a new RestService instance
+     * @summary Creates a new service instance with the specified adapter and optional model class.
+     * The constructor stores the adapter and model class for later use in CRUD operations.
+     * @param {A} adapter - The HTTP adapter instance to use for API requests
+     * @param {Constructor<M>} [clazz] - Optional constructor for the model class
+     */
+    constructor(adapter: A, clazz?: Constructor<M>);
+    toString(): string;
+}

package/lib/types/RestService.d.mts

@@ -0,0 +1,74 @@
+import { Model } from "@decaf-ts/decorator-validation";
+import { Constructor } from "@decaf-ts/decoration";
+import { HttpAdapter } from "./adapter.js";
+import { RestRepository } from "./RestRepository.js";
+/**
+ * @description Service class for REST API operations
+ * @summary Provides a comprehensive implementation for interacting with REST APIs.
+ * This class implements CRUD operations for single and bulk operations, as well as
+ * the Observable pattern to notify observers of changes. It works with HTTP adapters
+ * to perform the actual API requests and handles model conversion.
+ * @template M - The model type, extending Model
+ * @template Q - The query type used by the adapter
+ * @template A - The HTTP adapter type, extending HttpAdapter
+ * @template F - The HTTP flags type, extending HttpFlags
+ * @template C - The context type, extending Context<F>
+ * @param {A} adapter - The HTTP adapter instance
+ * @param {Constructor<M>} [clazz] - Optional constructor for the model class
+ * @class RestService
+ * @example
+ * ```typescript
+ * // Create a service for User model with Axios adapter
+ * const axiosAdapter = new AxiosAdapter({
+ *   protocol: 'https',
+ *   host: 'api.example.com'
+ * });
+ * const userService = new RestService(axiosAdapter, User);
+ *
+ * // Create a new user
+ * const user = new User({ name: 'John Doe', email: 'john@example.com' });
+ * const createdUser = await userService.create(user);
+ *
+ * // Update a user
+ * createdUser.name = 'Jane Doe';
+ * const updatedUser = await userService.update(createdUser);
+ *
+ * // Delete a user
+ * await userService.delete(updatedUser.id);
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Service as RestService
+ *   participant Adapter as HttpAdapter
+ *   participant API
+ *   Client->>Service: create(model)
+ *   Service->>Adapter: prepare(model, pk)
+ *   Service->>Adapter: create(table, id, record)
+ *   Adapter->>API: HTTP POST
+ *   API-->>Adapter: 201 Created
+ *   Adapter-->>Service: record
+ *   Service-->>Client: revert(record)
+ */
+export declare class RestService<M extends Model, A extends HttpAdapter<any, any, any, any, any>, Q = A extends HttpAdapter<any, any, any, infer Q, any> ? Q : never> extends RestRepository<M, A, Q> {
+    protected _overrides: Partial<import("@decaf-ts/core").FlagsOf<import("@decaf-ts/core").ContextOf<A>>> & {
+        allowRawStatements: boolean;
+        forcePrepareSimpleQueries: boolean;
+        forcePrepareComplexQueries: boolean;
+    } & {
+        ignoreValidation: boolean;
+        ignoreHandlers: boolean;
+        allowRawStatements: boolean;
+        forcePrepareSimpleQueries: boolean;
+        forcePrepareComplexQueries: boolean;
+    };
+    /**
+     * @description Initializes a new RestService instance
+     * @summary Creates a new service instance with the specified adapter and optional model class.
+     * The constructor stores the adapter and model class for later use in CRUD operations.
+     * @param {A} adapter - The HTTP adapter instance to use for API requests
+     * @param {Constructor<M>} [clazz] - Optional constructor for the model class
+     */
+    constructor(adapter: A, clazz?: Constructor<M>);
+    toString(): string;
+}

package/lib/types/adapter.d.cts

@@ -0,0 +1,230 @@
+import { Adapter, AdapterFlags, Condition, Context, ContextualArgs, FlagsOf, MaybeContextualArg, Paginator, PreparedModel, PreparedStatement, Repository, Sequence, SequenceOptions, Statement } from "@decaf-ts/core";
+import { BaseError, OperationKeys, PrimaryKeyType } from "@decaf-ts/db-decorators";
+import { HttpConfig, HttpFlags, HttpMethod, HttpRequestOptions, HttpResponse } from "./types.cjs";
+import { Model } from "@decaf-ts/decorator-validation";
+import { Constructor } from "@decaf-ts/decoration";
+export declare function suffixMethod(obj: any, before: (...args: any[]) => any, suffix: (...args: any[]) => any, beforeName?: string): void;
+/**
+ * @description Abstract HTTP adapter for REST API interactions
+ * @summary Provides a base implementation for HTTP adapters with methods for CRUD operations,
+ * URL construction, and error handling. This class extends the core Adapter class and
+ * implements the necessary methods for HTTP communication. Concrete implementations
+ * must provide specific HTTP client functionality.
+ * @template Y - The native HTTP client type
+ * @template Q - The query type used by the adapter
+ * @template F - The HTTP flags type, extending HttpFlags
+ * @template C - The context type, extending Context<F>
+ * @param {Y} native - The native HTTP client instance
+ * @param {HttpConfig} config - Configuration for the HTTP adapter
+ * @param {string} flavour - The adapter flavor identifier
+ * @param {string} [alias] - Optional alias for the adapter
+ * @class HttpAdapter
+ * @example
+ * ```typescript
+ * // Example implementation with Axios
+ * class AxiosAdapter extends HttpAdapter<AxiosInstance, AxiosRequestConfig> {
+ *   constructor(config: HttpConfig) {
+ *     super(axios.create(), config, 'axios');
+ *   }
+ *
+ *   async request<V>(details: AxiosRequestConfig): Promise<V> {
+ *     const response = await this.native.request(details);
+ *     return response.data;
+ *   }
+ *
+ *   // Implement other abstract methods...
+ * }
+ * ```
+ */
+export declare abstract class HttpAdapter<CONF extends HttpConfig, CON, REQ, Q extends PreparedStatement<any> = PreparedStatement<any>, C extends Context<HttpFlags> = Context<HttpFlags>> extends Adapter<CONF, CON, Q, C> {
+    protected constructor(config: CONF, flavour: string, alias?: string);
+    /**
+     * @description Generates operation flags with HTTP headers
+     * @summary Extends the base flags method to ensure HTTP headers exist on the flags payload.
+     * @template M - The model type
+     * @param {OperationKeys|string} operation - The type of operation being performed
+     * @param {Constructor | Constructor[]} model - The target model constructor(s)
+     * @param {Partial<FlagsOf<C>>} overrides - Optional flag overrides
+     * @param {...any[]} args - Additional arguments forwarded to the base implementation
+     * @return {Promise<FlagsOf<C>>} The flags object with headers
+     */
+    protected flags<M extends Model>(operation: OperationKeys | string, model: Constructor<M> | Constructor<M>[], overrides: Partial<FlagsOf<C>>): Promise<FlagsOf<C>>;
+    protected Dispatch(): any;
+    protected getEventHeaders(): Promise<{}>;
+    /**
+     * @description Returns the repository constructor for this adapter
+     * @summary Provides the RestService class as the repository implementation for this HTTP adapter.
+     * This method is used to create repository instances that work with this adapter type.
+     * @template R - Repository subtype working with this adapter
+     * @return {Constructor<R>} The repository constructor
+     */
+    repository<R extends Repository<any, Adapter<CONF, CON, Q, C>>>(): Constructor<R>;
+    /**
+     * @description Prepares a model for persistence
+     * @summary Converts a model instance into a format suitable for database storage,
+     * handling column mapping and separating transient properties
+     * @template M - The model type
+     * @param {M} model - The model instance to prepare
+     * @param pk - The primary key property name
+     * @param args
+     * @return The prepared data
+     */
+    prepare<M extends Model>(model: M, ...args: ContextualArgs<C>): PreparedModel;
+    /**
+     * @description Converts database data back into a model instance
+     * @summary Reconstructs a model instance from database data, handling column mapping
+     * and reattaching transient properties
+     * @template M - The model type
+     * @param obj - The database record
+     * @param {string|Constructor<M>} clazz - The model class or name
+     * @param pk - The primary key property name
+     * @param {string|number|bigint} id - The primary key value
+     * @return {M} The reconstructed model instance
+     */
+    revert<M extends Model>(obj: Record<string, any>, clazz: string | Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<C>): M;
+    protected toTableName<M extends Model>(t: string | Constructor<M>): string;
+    protected toHeaders(ctx: C): {
+        [x: string]: any;
+    };
+    /**
+     * @description Constructs a URL for API requests
+     * @summary Builds a complete URL for API requests using the configured protocol and host,
+     * the specified table name, and optional query parameters. The method handles URL encoding.
+     * @param {string | Constructor} tableName - The name of the table or endpoint
+     * @return {string} The encoded URL string
+     */
+    url<M extends Model>(tableName: string | Constructor<M>): string;
+    /**
+     * @description Constructs a URL for API requests
+     * @summary Builds a complete URL for API requests using the configured protocol and host,
+     * the specified table name, and optional query parameters. The method handles URL encoding.
+     * @param {string | Constructor} tableName - The name of the table or endpoint
+     * @param {string[]} pathParams - Optional query parameters
+     * @return {string} The encoded URL string
+     */
+    url<M extends Model>(tableName: string | Constructor<M>, pathParams: string[]): string;
+    /**
+     * @description Constructs a URL for API requests
+     * @summary Builds a complete URL for API requests using the configured protocol and host,
+     * the specified table name, and optional query parameters. The method handles URL encoding.
+     * @param {string | Constructor} tableName - The name of the table or endpoint
+     * @param {Record<string, string | number>} queryParams - Optional query parameters
+     * @return {string} The encoded URL string
+     */
+    url<M extends Model>(tableName: string | Constructor<M>, queryParams: Record<string, string | number>): string;
+    url<M extends Model>(tableName: string | Constructor<M>, pathParams: string[], queryParams: Record<string, string | number>): string;
+    abstract toRequest(query: Q): REQ;
+    abstract toRequest(ctx: C): REQ;
+    abstract toRequest(query: Q, ctx: C): REQ;
+    abstract toRequest(method: HttpMethod, url: string, data?: unknown, options?: HttpRequestOptions): REQ;
+    abstract toRequest(ctxOrQueryOrMethod: C | Q | HttpMethod, ctxOrUrl?: C | string, data?: unknown, options?: HttpRequestOptions): REQ;
+    protected toHttpResponse<V = any, E = unknown>(parsed: any, raw?: any): HttpResponse<V, E>;
+    get<V = any, E = unknown>(url: string, options?: HttpRequestOptions, ...args: MaybeContextualArg<C>): Promise<HttpResponse<V, E>>;
+    post<V = any, E = unknown>(url: string, data: unknown, options?: HttpRequestOptions, ...args: MaybeContextualArg<C>): Promise<HttpResponse<V, E>>;
+    put<V = any, E = unknown>(url: string, data: unknown, options?: HttpRequestOptions, ...args: MaybeContextualArg<C>): Promise<HttpResponse<V, E>>;
+    /**
+     * @description Sends an HTTP request
+     * @summary Abstract method that must be implemented by subclasses to send HTTP requests
+     * using the native HTTP client. This is the core method for making API calls.
+     * @template V - The response value type
+     * @param {REQ} details - The request details specific to the HTTP client
+     * @return {Promise<V>} A promise that resolves with the response data
+     */
+    abstract request<V>(details: REQ, ...args: MaybeContextualArg<C>): Promise<V>;
+    protected extractIdArgs<M extends Model>(model: Constructor<M> | string, id: PrimaryKeyType): string[];
+    parseResponse<M extends Model>(clazz: Constructor<M> | undefined, method: OperationKeys | string, res: any): any;
+    /**
+     * @description Creates a new resource
+     * @summary Abstract method that must be implemented by subclasses to create a new resource
+     * via HTTP. This typically corresponds to a POST request.
+     * @param {string} tableName - The name of the table or endpoint
+     * @param {string|number} id - The identifier for the resource
+     * @param {Record<string, any>} model - The data model to create
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<Record<string, any>>} A promise that resolves with the created resource
+     */
+    create<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<C>): Promise<Record<string, any>>;
+    createAll<M extends Model>(tableName: Constructor<M>, ids: PrimaryKeyType[], model: Record<string, any>[], ...args: ContextualArgs<C>): Promise<Record<string, any>[]>;
+    /**
+     * @description Retrieves a resource by ID
+     * @summary Abstract method that must be implemented by subclasses to retrieve a resource
+     * via HTTP. This typically corresponds to a GET request.
+     * @param {string} tableName - The name of the table or endpoint
+     * @param {string|number|bigint} id - The identifier for the resource
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<Record<string, any>>} A promise that resolves with the retrieved resource
+     */
+    read<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<C>): Promise<Record<string, any>>;
+    readAll<M extends Model>(tableName: Constructor<M>, ids: PrimaryKeyType[], ...args: ContextualArgs<C>): Promise<Record<string, any>[]>;
+    /**
+     * @description Updates an existing resource
+     * @summary Abstract method that must be implemented by subclasses to update a resource
+     * via HTTP. This typically corresponds to a PUT or PATCH request.
+     * @param {string} tableName - The name of the table or endpoint
+     * @param {string|number} id - The identifier for the resource
+     * @param {Record<string, any>} model - The updated data model
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<Record<string, any>>} A promise that resolves with the updated resource
+     */
+    update<M extends Model>(tableName: Constructor<M>, id: string | number, model: Record<string, any>, ...args: ContextualArgs<C>): Promise<Record<string, any>>;
+    updateAll<M extends Model>(tableName: Constructor<M>, ids: PrimaryKeyType[], model: Record<string, any>[], ...args: ContextualArgs<C>): Promise<Record<string, any>[]>;
+    /**
+     * @description Deletes a resource by ID
+     * @summary Abstract method that must be implemented by subclasses to delete a resource
+     * via HTTP. This typically corresponds to a DELETE request.
+     * @param {string} tableName - The name of the table or endpoint
+     * @param {string|number|bigint} id - The identifier for the resource to delete
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<Record<string, any>>} A promise that resolves with the deletion result
+     */
+    delete<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<C>): Promise<Record<string, any>>;
+    delete<V = any>(url: string, options?: HttpRequestOptions, ...args: MaybeContextualArg<C>): Promise<HttpResponse<V>>;
+    deleteAll<M extends Model>(tableName: Constructor<M>, ids: PrimaryKeyType[], ...args: ContextualArgs<C>): Promise<Record<string, any>[]>;
+    /**
+     * @description Executes a raw query
+     * @summary Method for executing raw queries directly with the HTTP client.
+     * This method is not supported by default in HTTP adapters and throws an UnsupportedError.
+     * Subclasses can override this method to provide implementation.
+     * @template R - The result type
+     * @param {Q} rawInput - The raw query input
+     * @param {boolean} process - Whether to process the result
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<R>} A promise that resolves with the query result
+     * @throws {UnsupportedError} Always throws as this method is not supported by default
+     */
+    raw<R>(rawInput: Q, ...args: ContextualArgs<C>): Promise<R>;
+    /**
+     * @description Creates a sequence
+     * @summary Method for creating a sequence for generating unique identifiers.
+     * This method is not supported by default in HTTP adapters and throws an UnsupportedError.
+     * Subclasses can override this method to provide implementation.
+     * @param {SequenceOptions} options - Options for creating the sequence
+     * @return {Promise<Sequence>} A promise that resolves with the created sequence
+     * @throws {UnsupportedError} Always throws as this method is not supported by default
+     */
+    Sequence(options: SequenceOptions): Promise<Sequence>;
+    /**
+     * @description Creates a statement for querying
+     * @summary Method for creating a statement for building and executing queries.
+     * This method is not supported by default in HTTP adapters and throws an UnsupportedError.
+     * Subclasses can override this method to provide implementation.
+     * @template M - The model type
+     * @template ! - The raw query type
+     * @return {Statement<Q, M, any>} A statement object for building queries
+     * @throws {UnsupportedError} Always throws as this method is not supported by default
+     */
+    Statement<M extends Model>(overrides?: Partial<AdapterFlags>): Statement<M, Adapter<CONF, CON, Q, C>, any>;
+    Paginator<M extends Model>(query: Q, size: number, clazz: Constructor<M>): Paginator<M, M, Q>;
+    /**
+     * @description Parses a condition into a query
+     * @summary Method for parsing a condition object into a query format understood by the HTTP client.
+     * This method is not supported by default in HTTP adapters and throws an UnsupportedError.
+     * Subclasses can override this method to provide implementation.
+     * @param {Condition<any>} condition - The condition to parse
+     * @return {Q} The parsed query
+     * @throws {UnsupportedError} Always throws as this method is not supported by default
+     */
+    parseCondition(condition: Condition<any>): Q;
+    static parseError<E extends BaseError>(err: Error | string, ...args: any[]): E;
+    static decoration(): void;
+}