@decaf-ts/for-http 0.2.0 → 0.2.2

package/lib/RestRepository.cjs

@@ -2,10 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestRepository = void 0;
 const core_1 = require("@decaf-ts/core");
+/**
+ * @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
+ * @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');
+ * ```
+ * @class RestRepository
+ * @see {@link RestService}
+ */
 class RestRepository extends core_1.Repository {
     constructor(adapter, clazz) {
         super(adapter, clazz);
     }
 }
 exports.RestRepository = RestRepository;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVzdFJlcG9zaXRvcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvUmVzdFJlcG9zaXRvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEseUNBQTRDO0FBSzVDLE1BQWEsY0FNWCxTQUFRLGlCQUFtQjtJQUMzQixZQUFZLE9BQVUsRUFBRSxLQUFzQjtRQUM1QyxLQUFLLENBQUMsT0FBTyxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBQ3hCLENBQUM7Q0FDRjtBQVZELHdDQVVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmVwb3NpdG9yeSB9IGZyb20gXCJAZGVjYWYtdHMvY29yZVwiO1xuaW1wb3J0IHsgQ29uc3RydWN0b3IsIE1vZGVsIH0gZnJvbSBcIkBkZWNhZi10cy9kZWNvcmF0b3ItdmFsaWRhdGlvblwiO1xuaW1wb3J0IHsgSHR0cEFkYXB0ZXIgfSBmcm9tIFwiLi9hZGFwdGVyXCI7XG5pbXBvcnQgeyBDb250ZXh0LCBSZXBvc2l0b3J5RmxhZ3MgfSBmcm9tIFwiQGRlY2FmLXRzL2RiLWRlY29yYXRvcnNcIjtcblxuZXhwb3J0IGNsYXNzIFJlc3RSZXBvc2l0b3J5PFxuICBNIGV4dGVuZHMgTW9kZWwsXG4gIFEsXG4gIEEgZXh0ZW5kcyBIdHRwQWRhcHRlcjxhbnksIFEsIEYsIEM+LFxuICBGIGV4dGVuZHMgUmVwb3NpdG9yeUZsYWdzLFxuICBDIGV4dGVuZHMgQ29udGV4dDxGPiA9IENvbnRleHQ8Rj4sXG4+IGV4dGVuZHMgUmVwb3NpdG9yeTxNLCBRLCBBPiB7XG4gIGNvbnN0cnVjdG9yKGFkYXB0ZXI6IEEsIGNsYXp6PzogQ29uc3RydWN0b3I8TT4pIHtcbiAgICBzdXBlcihhZGFwdGVyLCBjbGF6eik7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVzdFJlcG9zaXRvcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvUmVzdFJlcG9zaXRvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEseUNBQTRDO0FBTTVDOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBNEJHO0FBQ0gsTUFBYSxjQU1YLFNBQVEsaUJBQW1CO0lBQzNCLFlBQVksT0FBVSxFQUFFLEtBQXNCO1FBQzVDLEtBQUssQ0FBQyxPQUFPLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDeEIsQ0FBQztDQUNGO0FBVkQsd0NBVUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZXBvc2l0b3J5IH0gZnJvbSBcIkBkZWNhZi10cy9jb3JlXCI7XG5pbXBvcnQgeyBDb25zdHJ1Y3RvciwgTW9kZWwgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5pbXBvcnQgeyBIdHRwQWRhcHRlciB9IGZyb20gXCIuL2FkYXB0ZXJcIjtcbmltcG9ydCB7IENvbnRleHQgfSBmcm9tIFwiQGRlY2FmLXRzL2RiLWRlY29yYXRvcnNcIjtcbmltcG9ydCB7IEh0dHBGbGFncyB9IGZyb20gXCIuL3R5cGVzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIFJlcG9zaXRvcnkgZm9yIFJFU1QgQVBJIGludGVyYWN0aW9uc1xuICogQHN1bW1hcnkgQSBzcGVjaWFsaXplZCByZXBvc2l0b3J5IGltcGxlbWVudGF0aW9uIGZvciBpbnRlcmFjdGluZyB3aXRoIFJFU1QgQVBJcy5cbiAqIFRoaXMgY2xhc3MgZXh0ZW5kcyB0aGUgY29yZSBSZXBvc2l0b3J5IGNsYXNzIGFuZCB3b3JrcyB3aXRoIEhUVFAgYWRhcHRlcnMgdG9cbiAqIHByb3ZpZGUgQ1JVRCBvcGVyYXRpb25zIGZvciBtb2RlbHMgdmlhIFJFU1QgZW5kcG9pbnRzLlxuICogVGhpcyBJcyBOT1QgdGhlIGRlZmF1bHQgcmVwb3NpdG9yeSBmb3IgdGhlIEhUVFAgYWRhcHRlci4gVGhhdCB3b3VsZCBiZSB7QGxpbmsgUmVzdFNlcnZpY2V9LlxuICogVXNlIHRoaXMgb25seSBpbiB0aGUgc3BlY2lmaWMgY2FzZSBvZiBuZWVkaW5nIHRvIHJ1biB0aGUgQ1VSRCBtb2RlbCBsb2dpYyAoZGVjb3JhdGlvbikgYmVmb3JlIHN1Ym1pdHRpbmcgdG8gdGhlIGJhY2tlbmRcbiAqIEB0ZW1wbGF0ZSBNIC0gVGhlIG1vZGVsIHR5cGUsIGV4dGVuZGluZyBNb2RlbFxuICogQHRlbXBsYXRlIFEgLSBUaGUgcXVlcnkgdHlwZSB1c2VkIGJ5IHRoZSBhZGFwdGVyXG4gKiBAdGVtcGxhdGUgQSAtIFRoZSBIVFRQIGFkYXB0ZXIgdHlwZSwgZXh0ZW5kaW5nIEh0dHBBZGFwdGVyXG4gKiBAdGVtcGxhdGUgRiAtIFRoZSBIVFRQIGZsYWdzIHR5cGUsIGV4dGVuZGluZyBIdHRwRmxhZ3NcbiAqIEB0ZW1wbGF0ZSBDIC0gVGhlIGNvbnRleHQgdHlwZSwgZXh0ZW5kaW5nIENvbnRleHQ8Rj5cbiAqIEBwYXJhbSB7QX0gYWRhcHRlciAtIFRoZSBIVFRQIGFkYXB0ZXIgaW5zdGFuY2VcbiAqIEBwYXJhbSB7Q29uc3RydWN0b3I8TT59IFtjbGF6el0gLSBPcHRpb25hbCBjb25zdHJ1Y3RvciBmb3IgdGhlIG1vZGVsIGNsYXNzXG4gKiBAZXhhbXBsZVxuICogYGBgdHlwZXNjcmlwdFxuICogLy8gQ3JlYXRlIGEgcmVwb3NpdG9yeSBmb3IgVXNlciBtb2RlbCB3aXRoIEF4aW9zIGFkYXB0ZXJcbiAqIGNvbnN0IGF4aW9zQWRhcHRlciA9IG5ldyBBeGlvc0FkYXB0ZXIoe1xuICogICBwcm90b2NvbDogJ2h0dHBzJyxcbiAqICAgaG9zdDogJ2FwaS5leGFtcGxlLmNvbSdcbiAqIH0pO1xuICogY29uc3QgdXNlclJlcG9zaXRvcnkgPSBuZXcgUmVzdFJlcG9zaXRvcnkoYXhpb3NBZGFwdGVyLCBVc2VyKTtcbiAqXG4gKiAvLyBVc2UgdGhlIHJlcG9zaXRvcnkgZm9yIENSVUQgb3BlcmF0aW9uc1xuICogY29uc3QgdXNlciA9IGF3YWl0IHVzZXJSZXBvc2l0b3J5LmZpbmRCeUlkKCcxMjMnKTtcbiAqIGBgYFxuICogQGNsYXNzIFJlc3RSZXBvc2l0b3J5XG4gKiBAc2VlIHtAbGluayBSZXN0U2VydmljZX1cbiAqL1xuZXhwb3J0IGNsYXNzIFJlc3RSZXBvc2l0b3J5PFxuICBNIGV4dGVuZHMgTW9kZWwsXG4gIFEsXG4gIEEgZXh0ZW5kcyBIdHRwQWRhcHRlcjxhbnksIFEsIEYsIEM+LFxuICBGIGV4dGVuZHMgSHR0cEZsYWdzID0gSHR0cEZsYWdzLFxuICBDIGV4dGVuZHMgQ29udGV4dDxGPiA9IENvbnRleHQ8Rj4sXG4+IGV4dGVuZHMgUmVwb3NpdG9yeTxNLCBRLCBBPiB7XG4gIGNvbnN0cnVjdG9yKGFkYXB0ZXI6IEEsIGNsYXp6PzogQ29uc3RydWN0b3I8TT4pIHtcbiAgICBzdXBlcihhZGFwdGVyLCBjbGF6eik7XG4gIH1cbn1cbiJdfQ==

package/lib/RestRepository.d.ts

@@ -1,7 +1,37 @@
 import { Repository } from "@decaf-ts/core";
 import { Constructor, Model } from "@decaf-ts/decorator-validation";
 import { HttpAdapter } from "./adapter";
-import { Context, RepositoryFlags } from "@decaf-ts/db-decorators";
-export declare class RestRepository<M extends Model, Q, A extends HttpAdapter<any, Q, F, C>, F extends RepositoryFlags, C extends Context<F> = Context<F>> extends Repository<M, Q, A> {
+import { Context } from "@decaf-ts/db-decorators";
+import { HttpFlags } from "./types";
+/**
+ * @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
+ * @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');
+ * ```
+ * @class RestRepository
+ * @see {@link RestService}
+ */
+export declare class RestRepository<M extends Model, Q, A extends HttpAdapter<any, Q, F, C>, F extends HttpFlags = HttpFlags, C extends Context<F> = Context<F>> extends Repository<M, Q, A> {
     constructor(adapter: A, clazz?: Constructor<M>);
 }

package/lib/RestService.cjs

@@ -3,53 +3,164 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestService = void 0;
 const db_decorators_1 = require("@decaf-ts/db-decorators");
 const core_1 = require("@decaf-ts/core");
+/**
+ * @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
+ * @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);
+ * ```
+ * @class
+ */
 class RestService {
+    /**
+     * @description Gets the model class constructor
+     * @summary Retrieves the model class constructor associated with this service.
+     * Throws an error if no class definition is found.
+     * @return {Constructor<M>} The model class constructor
+     * @throws {InternalError} If no class definition is found
+     */
     get class() {
         if (!this._class)
             throw new db_decorators_1.InternalError("No class definition found for this repository");
         return this._class;
     }
+    /**
+     * @description Gets the primary key property name
+     * @summary Retrieves the name of the primary key property for the model.
+     * If not already determined, it finds the primary key using the model class.
+     * @return The primary key property name
+     */
     get pk() {
         if (!this._pk)
             this._pk = (0, db_decorators_1.findPrimaryKey)(new this.class()).id;
         return this._pk;
     }
+    /**
+     * @description Gets the HTTP adapter
+     * @summary Retrieves the HTTP adapter associated with this service.
+     * Throws an error if no adapter is found.
+     * @return {A} The HTTP adapter instance
+     * @throws {InternalError} If no adapter is found
+     */
     get adapter() {
         if (!this._adapter)
             throw new db_decorators_1.InternalError("No adapter found for this repository. did you use the @uses decorator or pass it in the constructor?");
         return this._adapter;
     }
+    /**
+     * @description Gets the table name for the model
+     * @summary Retrieves the table name associated with the model class.
+     * If not already determined, it gets the table name from the Repository utility.
+     * @return {string} The table name
+     */
     get tableName() {
         if (!this._tableName)
             this._tableName = core_1.Repository.table(this.class);
         return this._tableName;
     }
+    /**
+     * @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, clazz) {
         this.observers = [];
         this._adapter = adapter;
         if (clazz)
             this._class = clazz;
     }
+    /**
+     * @description Creates a new resource
+     * @summary Creates a new resource in the REST API using the provided model.
+     * The method prepares the model for the adapter, sends the create request,
+     * and then converts the response back to a model instance.
+     * @param {M} model - The model instance to create
+     * @param {...any[]} args - Additional arguments to pass to the adapter
+     * @return {Promise<M>} A promise that resolves with the created model instance
+     */
     async create(model, ...args) {
         // eslint-disable-next-line prefer-const
         let { record, id } = this.adapter.prepare(model, this.pk);
         record = await this.adapter.create(this.tableName, id, record, ...args);
         return this.adapter.revert(record, this.class, this.pk, id);
     }
+    /**
+     * @description Retrieves a resource by ID
+     * @summary Fetches a resource from the REST API using the provided ID.
+     * The method sends the read request and converts the response to a model instance.
+     * @param {string|number} id - The identifier of the resource to retrieve
+     * @param {...any[]} args - Additional arguments to pass to the adapter
+     * @return {Promise<M>} A promise that resolves with the retrieved model instance
+     */
     async read(id, ...args) {
         const m = await this.adapter.read(this.tableName, id, ...args);
         return this.adapter.revert(m, this.class, this.pk, id);
     }
+    /**
+     * @description Updates an existing resource
+     * @summary Updates an existing resource in the REST API using the provided model.
+     * The method prepares the model for the adapter, sends the update request,
+     * and then converts the response back to a model instance.
+     * @param {M} model - The model instance with updated data
+     * @param {...any[]} args - Additional arguments to pass to the adapter
+     * @return {Promise<M>} A promise that resolves with the updated model instance
+     */
     async update(model, ...args) {
         // eslint-disable-next-line prefer-const
         let { record, id } = this.adapter.prepare(model, this.pk);
         record = await this.adapter.update(this.tableName, id, record, ...args);
         return this.adapter.revert(record, this.class, this.pk, id);
     }
+    /**
+     * @description Deletes a resource by ID
+     * @summary Removes a resource from the REST API using the provided ID.
+     * The method sends the delete request and converts the response to a model instance.
+     * @param {string|number} id - The identifier of the resource to delete
+     * @param {...any[]} args - Additional arguments to pass to the adapter
+     * @return {Promise<M>} A promise that resolves with the deleted model instance
+     */
     async delete(id, ...args) {
         const m = await this.adapter.delete(this.tableName, id, ...args);
         return this.adapter.revert(m, this.class, this.pk, id);
     }
+    /**
+     * @description Creates multiple resources
+     * @summary Creates multiple resources in the REST API using the provided models.
+     * The method prepares each model for the adapter, sends a bulk create request,
+     * and then converts the responses back to model instances.
+     * @param {M[]} models - The model instances to create
+     * @param {...any[]} args - Additional arguments to pass to the adapter
+     * @return {Promise<M[]>} A promise that resolves with an array of created model instances
+     */
     async createAll(models, ...args) {
         if (!models.length)
             return models;
@@ -59,24 +170,51 @@ class RestService {
         records = await this.adapter.createAll(this.tableName, ids, records, ...args);
         return records.map((r, i) => this.adapter.revert(r, this.class, this.pk, ids[i]));
     }
+    /**
+     * @description Deletes multiple resources by IDs
+     * @summary Removes multiple resources from the REST API using the provided IDs.
+     * The method sends a bulk delete request and converts the responses to model instances.
+     * @param {string[]|number[]} keys - The identifiers of the resources to delete
+     * @param {...any[]} args - Additional arguments to pass to the adapter
+     * @return {Promise<M[]>} A promise that resolves with an array of deleted model instances
+     */
     async deleteAll(keys, ...args) {
         const results = await this.adapter.deleteAll(this.tableName, keys, ...args);
         return results.map((r, i) => this.adapter.revert(r, this.class, this.pk, keys[i]));
     }
+    /**
+     * @description Retrieves multiple resources by IDs
+     * @summary Fetches multiple resources from the REST API using the provided IDs.
+     * The method sends a bulk read request and converts the responses to model instances.
+     * @param {string[]|number[]} keys - The identifiers of the resources to retrieve
+     * @param {...any[]} args - Additional arguments to pass to the adapter
+     * @return {Promise<M[]>} A promise that resolves with an array of retrieved model instances
+     */
     async readAll(keys, ...args) {
         const records = await this.adapter.readAll(this.tableName, keys, ...args);
         return records.map((r, i) => this.adapter.revert(r, this.class, this.pk, keys[i]));
     }
+    /**
+     * @description Updates multiple resources
+     * @summary Updates multiple resources in the REST API using the provided models.
+     * The method prepares each model for the adapter, sends a bulk update request,
+     * and then converts the responses back to model instances.
+     * @param {M[]} models - The model instances with updated data
+     * @param {...any[]} args - Additional arguments to pass to the adapter
+     * @return {Promise<M[]>} A promise that resolves with an array of updated model instances
+     */
     async updateAll(models, ...args) {
         const records = models.map((m) => this.adapter.prepare(m, this.pk));
         const updated = await this.adapter.updateAll(this.tableName, records.map((r) => r.id), records.map((r) => r.record), ...args);
         return updated.map((u, i) => this.adapter.revert(u, this.class, this.pk, records[i].id));
     }
     /**
-     * @summary Registers an {@link Observer}
-     * @param {Observer} observer
-     *
-     * @see {Observable#observe}
+     * @description Registers an observer
+     * @summary Adds an observer to the list of observers that will be notified of changes.
+     * Throws an error if the observer is already registered.
+     * @param {Observer} observer - The observer to register
+     * @return {void}
+     * @throws {InternalError} If the observer is already registered
      */
     observe(observer) {
         const index = this.observers.indexOf(observer);
@@ -85,10 +223,12 @@ class RestService {
         this.observers.push(observer);
     }
     /**
-     * @summary Unregisters an {@link Observer}
-     * @param {Observer} observer
-     *
-     * @see {Observable#unObserve}
+     * @description Unregisters an observer
+     * @summary Removes an observer from the list of observers.
+     * Throws an error if the observer is not found.
+     * @param {Observer} observer - The observer to unregister
+     * @return {void}
+     * @throws {InternalError} If the observer is not found
      */
     unObserve(observer) {
         const index = this.observers.indexOf(observer);
@@ -97,8 +237,11 @@ class RestService {
         this.observers.splice(index, 1);
     }
     /**
-     * @summary calls all registered {@link Observer}s to update themselves
-     * @param {any[]} [args] optional arguments to be passed to the {@link Observer#refresh} method
+     * @description Notifies all registered observers
+     * @summary Calls the refresh method on all registered observers to update themselves.
+     * Any errors during observer refresh are logged as warnings but don't stop the process.
+     * @param {...any[]} [args] - Optional arguments to pass to the observer refresh method
+     * @return {Promise<void>} A promise that resolves when all observers have been updated
      */
     async updateObservers(...args) {
         const results = await Promise.allSettled(this.observers.map((o) => o.refresh(...args)));
@@ -109,4 +252,4 @@ class RestService {
     }
 }
 exports.RestService = RestService;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RestService.js","sourceRoot":"","sources":["../src/RestService.ts"],"names":[],"mappings":";;;AAAA,2DAOiC;AAEjC,yCAAkE;AAGlE,MAAa,WAAW;IAYtB,IAAI,KAAK;QACP,IAAI,CAAC,IAAI,CAAC,MAAM;YACd,MAAM,IAAI,6BAAa,CAAC,+CAA+C,CAAC,CAAC;QAC3E,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,IAAI,EAAE;QACJ,IAAI,CAAC,IAAI,CAAC,GAAG;YAAE,IAAI,CAAC,GAAG,GAAG,IAAA,8BAAc,EAAC,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC;QAC9D,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IAOD,IAAc,OAAO;QACnB,IAAI,CAAC,IAAI,CAAC,QAAQ;YAChB,MAAM,IAAI,6BAAa,CACrB,sGAAsG,CACvG,CAAC;QACJ,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,IAAc,SAAS;QACrB,IAAI,CAAC,IAAI,CAAC,UAAU;YAAE,IAAI,CAAC,UAAU,GAAG,iBAAU,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrE,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED,YAAY,OAAU,EAAE,KAAsB;QAlBpC,cAAS,GAAe,EAAE,CAAC;QAmBnC,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,IAAI,KAAK;YAAE,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACjC,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,KAAQ,EAAE,GAAG,IAAW;QACnC,wCAAwC;QACxC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;QAC1D,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC;QACxE,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;IAC9D,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,EAAmB,EAAE,GAAG,IAAW;QAC5C,MAAM,CAAC,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC;QAC/D,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;IACzD,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,KAAQ,EAAE,GAAG,IAAW;QACnC,wCAAwC;QACxC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;QAC1D,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC;QACxE,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;IAC9D,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,EAAmB,EAAE,GAAG,IAAW;QAC9C,MAAM,CAAC,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC;QACjE,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;IACzD,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,MAAW,EAAE,GAAG,IAAW;QACzC,IAAI,CAAC,MAAM,CAAC,MAAM;YAAE,OAAO,MAAM,CAAC;QAClC,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;QACrE,MAAM,GAAG,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACtC,IAAI,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QAC5C,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CACpC,IAAI,CAAC,SAAS,EACd,GAA0B,EAC1B,OAAO,EACP,GAAG,IAAI,CACR,CAAC;QACF,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAC1B,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,CAAoB,CAAC,CACvE,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,IAAyB,EAAE,GAAG,IAAW;QACvD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC;QAC5E,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAC1B,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CACrD,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,IAAyB,EAAE,GAAG,IAAW;QACrD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC;QAC1E,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAC1B,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CACrD,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,MAAW,EAAE,GAAG,IAAW;QACzC,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;QACpE,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAC1C,IAAI,CAAC,SAAS,EACd,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EACxB,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,EAC5B,GAAG,IAAI,CACR,CAAC;QACF,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAC1B,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAC3D,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,OAAO,CAAC,QAAkB;QACxB,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC/C,IAAI,KAAK,KAAK,CAAC,CAAC;YAAE,MAAM,IAAI,6BAAa,CAAC,6BAA6B,CAAC,CAAC;QACzE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAChC,CAAC;IAED;;;;;OAKG;IACH,SAAS,CAAC,QAAkB;QAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC/C,IAAI,KAAK,KAAK,CAAC,CAAC;YAAE,MAAM,IAAI,6BAAa,CAAC,yBAAyB,CAAC,CAAC;QACrE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAClC,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,eAAe,CAAC,GAAG,IAAW;QAClC,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,UAAU,CACtC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC,CAC9C,CAAC;QACF,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC5B,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU;gBAC9B,OAAO,CAAC,IAAI,CACV,+BAA+B,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,CACrE,CAAC;QACN,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAxJD,kCAwJC","sourcesContent":["import {\n  BulkCrudOperator,\n  Context,\n  CrudOperator,\n  findPrimaryKey,\n  InternalError,\n  RepositoryFlags,\n} from \"@decaf-ts/db-decorators\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { Observable, Observer, Repository } from \"@decaf-ts/core\";\nimport { HttpAdapter } from \"./adapter\";\n\nexport class RestService<\n    M extends Model,\n    Q,\n    A extends HttpAdapter<any, Q, F, C>,\n    F extends RepositoryFlags,\n    C extends Context<F> = Context<F>,\n  >\n  implements CrudOperator<M>, BulkCrudOperator<M>, Observable\n{\n  private readonly _class!: Constructor<M>;\n  private _pk!: keyof M;\n\n  get class() {\n    if (!this._class)\n      throw new InternalError(\"No class definition found for this repository\");\n    return this._class;\n  }\n\n  get pk() {\n    if (!this._pk) this._pk = findPrimaryKey(new this.class()).id;\n    return this._pk;\n  }\n\n  protected observers: Observer[] = [];\n\n  private readonly _adapter!: A;\n  private _tableName!: string;\n\n  protected get adapter(): A {\n    if (!this._adapter)\n      throw new InternalError(\n        \"No adapter found for this repository. did you use the @uses decorator or pass it in the constructor?\"\n      );\n    return this._adapter;\n  }\n\n  protected get tableName() {\n    if (!this._tableName) this._tableName = Repository.table(this.class);\n    return this._tableName;\n  }\n\n  constructor(adapter: A, clazz?: Constructor<M>) {\n    this._adapter = adapter;\n    if (clazz) this._class = clazz;\n  }\n\n  async create(model: M, ...args: any[]): Promise<M> {\n    // eslint-disable-next-line prefer-const\n    let { record, id } = this.adapter.prepare(model, this.pk);\n    record = await this.adapter.create(this.tableName, id, record, ...args);\n    return this.adapter.revert(record, this.class, this.pk, id);\n  }\n\n  async read(id: string | number, ...args: any[]): Promise<M> {\n    const m = await this.adapter.read(this.tableName, id, ...args);\n    return this.adapter.revert(m, this.class, this.pk, id);\n  }\n\n  async update(model: M, ...args: any[]): Promise<M> {\n    // eslint-disable-next-line prefer-const\n    let { record, id } = this.adapter.prepare(model, this.pk);\n    record = await this.adapter.update(this.tableName, id, record, ...args);\n    return this.adapter.revert(record, this.class, this.pk, id);\n  }\n\n  async delete(id: string | number, ...args: any[]): Promise<M> {\n    const m = await this.adapter.delete(this.tableName, id, ...args);\n    return this.adapter.revert(m, this.class, this.pk, id);\n  }\n\n  async createAll(models: M[], ...args: any[]): Promise<M[]> {\n    if (!models.length) return models;\n    const prepared = models.map((m) => this.adapter.prepare(m, this.pk));\n    const ids = prepared.map((p) => p.id);\n    let records = prepared.map((p) => p.record);\n    records = await this.adapter.createAll(\n      this.tableName,\n      ids as (string | number)[],\n      records,\n      ...args\n    );\n    return records.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, ids[i] as string | number)\n    );\n  }\n\n  async deleteAll(keys: string[] | number[], ...args: any[]): Promise<M[]> {\n    const results = await this.adapter.deleteAll(this.tableName, keys, ...args);\n    return results.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, keys[i])\n    );\n  }\n\n  async readAll(keys: string[] | number[], ...args: any[]): Promise<M[]> {\n    const records = await this.adapter.readAll(this.tableName, keys, ...args);\n    return records.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, keys[i])\n    );\n  }\n\n  async updateAll(models: M[], ...args: any[]): Promise<M[]> {\n    const records = models.map((m) => this.adapter.prepare(m, this.pk));\n    const updated = await this.adapter.updateAll(\n      this.tableName,\n      records.map((r) => r.id),\n      records.map((r) => r.record),\n      ...args\n    );\n    return updated.map((u, i) =>\n      this.adapter.revert(u, this.class, this.pk, records[i].id)\n    );\n  }\n\n  /**\n   * @summary Registers an {@link Observer}\n   * @param {Observer} observer\n   *\n   * @see {Observable#observe}\n   */\n  observe(observer: Observer): void {\n    const index = this.observers.indexOf(observer);\n    if (index !== -1) throw new InternalError(\"Observer already registered\");\n    this.observers.push(observer);\n  }\n\n  /**\n   * @summary Unregisters an {@link Observer}\n   * @param {Observer} observer\n   *\n   * @see {Observable#unObserve}\n   */\n  unObserve(observer: Observer): void {\n    const index = this.observers.indexOf(observer);\n    if (index === -1) throw new InternalError(\"Failed to find Observer\");\n    this.observers.splice(index, 1);\n  }\n\n  /**\n   * @summary calls all registered {@link Observer}s to update themselves\n   * @param {any[]} [args] optional arguments to be passed to the {@link Observer#refresh} method\n   */\n  async updateObservers(...args: any[]): Promise<void> {\n    const results = await Promise.allSettled(\n      this.observers.map((o) => o.refresh(...args))\n    );\n    results.forEach((result, i) => {\n      if (result.status === \"rejected\")\n        console.warn(\n          `Failed to update observable ${this.observers[i]}: ${result.reason}`\n        );\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RestService.js","sourceRoot":"","sources":["../src/RestService.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BulkCrudOperator,\n  Context,\n  CrudOperator,\n  findPrimaryKey,\n  InternalError,\n} from \"@decaf-ts/db-decorators\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { Observable, Observer, Repository } from \"@decaf-ts/core\";\nimport { HttpAdapter } from \"./adapter\";\nimport { HttpFlags } from \"./types\";\n\n/**\n * @description Service class for REST API operations\n * @summary Provides a comprehensive implementation for interacting with REST APIs.\n * This class implements CRUD operations for single and bulk operations, as well as\n * the Observable pattern to notify observers of changes. It works with HTTP adapters\n * to perform the actual API requests and handles model conversion.\n * @template M - The model type, extending Model\n * @template Q - The query type used by the adapter\n * @template A - The HTTP adapter type, extending HttpAdapter\n * @template F - The HTTP flags type, extending HttpFlags\n * @template C - The context type, extending Context<F>\n * @param {A} adapter - The HTTP adapter instance\n * @param {Constructor<M>} [clazz] - Optional constructor for the model class\n * @example\n * ```typescript\n * // Create a service for User model with Axios adapter\n * const axiosAdapter = new AxiosAdapter({\n *   protocol: 'https',\n *   host: 'api.example.com'\n * });\n * const userService = new RestService(axiosAdapter, User);\n *\n * // Create a new user\n * const user = new User({ name: 'John Doe', email: 'john@example.com' });\n * const createdUser = await userService.create(user);\n *\n * // Update a user\n * createdUser.name = 'Jane Doe';\n * const updatedUser = await userService.update(createdUser);\n *\n * // Delete a user\n * await userService.delete(updatedUser.id);\n * ```\n * @class\n */\nexport class RestService<\n    M extends Model,\n    Q,\n    A extends HttpAdapter<any, Q, F, C>,\n    F extends HttpFlags = HttpFlags,\n    C extends Context<F> = Context<F>,\n  >\n  implements CrudOperator<M>, BulkCrudOperator<M>, Observable\n{\n  private readonly _class!: Constructor<M>;\n  private _pk!: keyof M;\n\n  /**\n   * @description Gets the model class constructor\n   * @summary Retrieves the model class constructor associated with this service.\n   * Throws an error if no class definition is found.\n   * @return {Constructor<M>} The model class constructor\n   * @throws {InternalError} If no class definition is found\n   */\n  get class() {\n    if (!this._class)\n      throw new InternalError(\"No class definition found for this repository\");\n    return this._class;\n  }\n\n  /**\n   * @description Gets the primary key property name\n   * @summary Retrieves the name of the primary key property for the model.\n   * If not already determined, it finds the primary key using the model class.\n   * @return The primary key property name\n   */\n  get pk() {\n    if (!this._pk) this._pk = findPrimaryKey(new this.class()).id;\n    return this._pk;\n  }\n\n  protected observers: Observer[] = [];\n\n  private readonly _adapter!: A;\n  private _tableName!: string;\n\n  /**\n   * @description Gets the HTTP adapter\n   * @summary Retrieves the HTTP adapter associated with this service.\n   * Throws an error if no adapter is found.\n   * @return {A} The HTTP adapter instance\n   * @throws {InternalError} If no adapter is found\n   */\n  protected get adapter(): A {\n    if (!this._adapter)\n      throw new InternalError(\n        \"No adapter found for this repository. did you use the @uses decorator or pass it in the constructor?\"\n      );\n    return this._adapter;\n  }\n\n  /**\n   * @description Gets the table name for the model\n   * @summary Retrieves the table name associated with the model class.\n   * If not already determined, it gets the table name from the Repository utility.\n   * @return {string} The table name\n   */\n  protected get tableName() {\n    if (!this._tableName) this._tableName = Repository.table(this.class);\n    return this._tableName;\n  }\n\n  /**\n   * @description Initializes a new RestService instance\n   * @summary Creates a new service instance with the specified adapter and optional model class.\n   * The constructor stores the adapter and model class for later use in CRUD operations.\n   * @param {A} adapter - The HTTP adapter instance to use for API requests\n   * @param {Constructor<M>} [clazz] - Optional constructor for the model class\n   */\n  constructor(adapter: A, clazz?: Constructor<M>) {\n    this._adapter = adapter;\n    if (clazz) this._class = clazz;\n  }\n\n  /**\n   * @description Creates a new resource\n   * @summary Creates a new resource in the REST API using the provided model.\n   * The method prepares the model for the adapter, sends the create request,\n   * and then converts the response back to a model instance.\n   * @param {M} model - The model instance to create\n   * @param {...any[]} args - Additional arguments to pass to the adapter\n   * @return {Promise<M>} A promise that resolves with the created model instance\n   */\n  async create(model: M, ...args: any[]): Promise<M> {\n    // eslint-disable-next-line prefer-const\n    let { record, id } = this.adapter.prepare(model, this.pk);\n    record = await this.adapter.create(this.tableName, id, record, ...args);\n    return this.adapter.revert(record, this.class, this.pk, id);\n  }\n\n  /**\n   * @description Retrieves a resource by ID\n   * @summary Fetches a resource from the REST API using the provided ID.\n   * The method sends the read request and converts the response to a model instance.\n   * @param {string|number} id - The identifier of the resource to retrieve\n   * @param {...any[]} args - Additional arguments to pass to the adapter\n   * @return {Promise<M>} A promise that resolves with the retrieved model instance\n   */\n  async read(id: string | number, ...args: any[]): Promise<M> {\n    const m = await this.adapter.read(this.tableName, id, ...args);\n    return this.adapter.revert(m, this.class, this.pk, id);\n  }\n\n  /**\n   * @description Updates an existing resource\n   * @summary Updates an existing resource in the REST API using the provided model.\n   * The method prepares the model for the adapter, sends the update request,\n   * and then converts the response back to a model instance.\n   * @param {M} model - The model instance with updated data\n   * @param {...any[]} args - Additional arguments to pass to the adapter\n   * @return {Promise<M>} A promise that resolves with the updated model instance\n   */\n  async update(model: M, ...args: any[]): Promise<M> {\n    // eslint-disable-next-line prefer-const\n    let { record, id } = this.adapter.prepare(model, this.pk);\n    record = await this.adapter.update(this.tableName, id, record, ...args);\n    return this.adapter.revert(record, this.class, this.pk, id);\n  }\n\n  /**\n   * @description Deletes a resource by ID\n   * @summary Removes a resource from the REST API using the provided ID.\n   * The method sends the delete request and converts the response to a model instance.\n   * @param {string|number} id - The identifier of the resource to delete\n   * @param {...any[]} args - Additional arguments to pass to the adapter\n   * @return {Promise<M>} A promise that resolves with the deleted model instance\n   */\n  async delete(id: string | number, ...args: any[]): Promise<M> {\n    const m = await this.adapter.delete(this.tableName, id, ...args);\n    return this.adapter.revert(m, this.class, this.pk, id);\n  }\n\n  /**\n   * @description Creates multiple resources\n   * @summary Creates multiple resources in the REST API using the provided models.\n   * The method prepares each model for the adapter, sends a bulk create request,\n   * and then converts the responses back to model instances.\n   * @param {M[]} models - The model instances to create\n   * @param {...any[]} args - Additional arguments to pass to the adapter\n   * @return {Promise<M[]>} A promise that resolves with an array of created model instances\n   */\n  async createAll(models: M[], ...args: any[]): Promise<M[]> {\n    if (!models.length) return models;\n    const prepared = models.map((m) => this.adapter.prepare(m, this.pk));\n    const ids = prepared.map((p) => p.id);\n    let records = prepared.map((p) => p.record);\n    records = await this.adapter.createAll(\n      this.tableName,\n      ids as (string | number)[],\n      records,\n      ...args\n    );\n    return records.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, ids[i] as string | number)\n    );\n  }\n\n  /**\n   * @description Deletes multiple resources by IDs\n   * @summary Removes multiple resources from the REST API using the provided IDs.\n   * The method sends a bulk delete request and converts the responses to model instances.\n   * @param {string[]|number[]} keys - The identifiers of the resources to delete\n   * @param {...any[]} args - Additional arguments to pass to the adapter\n   * @return {Promise<M[]>} A promise that resolves with an array of deleted model instances\n   */\n  async deleteAll(keys: string[] | number[], ...args: any[]): Promise<M[]> {\n    const results = await this.adapter.deleteAll(this.tableName, keys, ...args);\n    return results.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, keys[i])\n    );\n  }\n\n  /**\n   * @description Retrieves multiple resources by IDs\n   * @summary Fetches multiple resources from the REST API using the provided IDs.\n   * The method sends a bulk read request and converts the responses to model instances.\n   * @param {string[]|number[]} keys - The identifiers of the resources to retrieve\n   * @param {...any[]} args - Additional arguments to pass to the adapter\n   * @return {Promise<M[]>} A promise that resolves with an array of retrieved model instances\n   */\n  async readAll(keys: string[] | number[], ...args: any[]): Promise<M[]> {\n    const records = await this.adapter.readAll(this.tableName, keys, ...args);\n    return records.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, keys[i])\n    );\n  }\n\n  /**\n   * @description Updates multiple resources\n   * @summary Updates multiple resources in the REST API using the provided models.\n   * The method prepares each model for the adapter, sends a bulk update request,\n   * and then converts the responses back to model instances.\n   * @param {M[]} models - The model instances with updated data\n   * @param {...any[]} args - Additional arguments to pass to the adapter\n   * @return {Promise<M[]>} A promise that resolves with an array of updated model instances\n   */\n  async updateAll(models: M[], ...args: any[]): Promise<M[]> {\n    const records = models.map((m) => this.adapter.prepare(m, this.pk));\n    const updated = await this.adapter.updateAll(\n      this.tableName,\n      records.map((r) => r.id),\n      records.map((r) => r.record),\n      ...args\n    );\n    return updated.map((u, i) =>\n      this.adapter.revert(u, this.class, this.pk, records[i].id)\n    );\n  }\n\n  /**\n   * @description Registers an observer\n   * @summary Adds an observer to the list of observers that will be notified of changes.\n   * Throws an error if the observer is already registered.\n   * @param {Observer} observer - The observer to register\n   * @return {void}\n   * @throws {InternalError} If the observer is already registered\n   */\n  observe(observer: Observer): void {\n    const index = this.observers.indexOf(observer);\n    if (index !== -1) throw new InternalError(\"Observer already registered\");\n    this.observers.push(observer);\n  }\n\n  /**\n   * @description Unregisters an observer\n   * @summary Removes an observer from the list of observers.\n   * Throws an error if the observer is not found.\n   * @param {Observer} observer - The observer to unregister\n   * @return {void}\n   * @throws {InternalError} If the observer is not found\n   */\n  unObserve(observer: Observer): void {\n    const index = this.observers.indexOf(observer);\n    if (index === -1) throw new InternalError(\"Failed to find Observer\");\n    this.observers.splice(index, 1);\n  }\n\n  /**\n   * @description Notifies all registered observers\n   * @summary Calls the refresh method on all registered observers to update themselves.\n   * Any errors during observer refresh are logged as warnings but don't stop the process.\n   * @param {...any[]} [args] - Optional arguments to pass to the observer refresh method\n   * @return {Promise<void>} A promise that resolves when all observers have been updated\n   */\n  async updateObservers(...args: any[]): Promise<void> {\n    const results = await Promise.allSettled(\n      this.observers.map((o) => o.refresh(...args))\n    );\n    results.forEach((result, i) => {\n      if (result.status === \"rejected\")\n        console.warn(\n          `Failed to update observable ${this.observers[i]}: ${result.reason}`\n        );\n    });\n  }\n}\n"]}

package/lib/RestService.d.ts

@@ -1,43 +1,187 @@
-import { BulkCrudOperator, Context, CrudOperator, RepositoryFlags } from "@decaf-ts/db-decorators";
+import { BulkCrudOperator, Context, CrudOperator } from "@decaf-ts/db-decorators";
 import { Constructor, Model } from "@decaf-ts/decorator-validation";
 import { Observable, Observer } from "@decaf-ts/core";
 import { HttpAdapter } from "./adapter";
-export declare class RestService<M extends Model, Q, A extends HttpAdapter<any, Q, F, C>, F extends RepositoryFlags, C extends Context<F> = Context<F>> implements CrudOperator<M>, BulkCrudOperator<M>, Observable {
+import { HttpFlags } from "./types";
+/**
+ * @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
+ * @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);
+ * ```
+ * @class
+ */
+export declare class RestService<M extends Model, Q, A extends HttpAdapter<any, Q, F, C>, F extends HttpFlags = HttpFlags, C extends Context<F> = Context<F>> implements CrudOperator<M>, BulkCrudOperator<M>, Observable {
     private readonly _class;
     private _pk;
+    /**
+     * @description Gets the model class constructor
+     * @summary Retrieves the model class constructor associated with this service.
+     * Throws an error if no class definition is found.
+     * @return {Constructor<M>} The model class constructor
+     * @throws {InternalError} If no class definition is found
+     */
     get class(): Constructor<M>;
+    /**
+     * @description Gets the primary key property name
+     * @summary Retrieves the name of the primary key property for the model.
+     * If not already determined, it finds the primary key using the model class.
+     * @return The primary key property name
+     */
     get pk(): keyof M;
     protected observers: Observer[];
     private readonly _adapter;
     private _tableName;
+    /**
+     * @description Gets the HTTP adapter
+     * @summary Retrieves the HTTP adapter associated with this service.
+     * Throws an error if no adapter is found.
+     * @return {A} The HTTP adapter instance
+     * @throws {InternalError} If no adapter is found
+     */
     protected get adapter(): A;
+    /**
+     * @description Gets the table name for the model
+     * @summary Retrieves the table name associated with the model class.
+     * If not already determined, it gets the table name from the Repository utility.
+     * @return {string} The table name
+     */
     protected get tableName(): string;
+    /**
+     * @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>);
+    /**
+     * @description Creates a new resource
+     * @summary Creates a new resource in the REST API using the provided model.
+     * The method prepares the model for the adapter, sends the create request,
+     * and then converts the response back to a model instance.
+     * @param {M} model - The model instance to create
+     * @param {...any[]} args - Additional arguments to pass to the adapter
+     * @return {Promise<M>} A promise that resolves with the created model instance
+     */
     create(model: M, ...args: any[]): Promise<M>;
+    /**
+     * @description Retrieves a resource by ID
+     * @summary Fetches a resource from the REST API using the provided ID.
+     * The method sends the read request and converts the response to a model instance.
+     * @param {string|number} id - The identifier of the resource to retrieve
+     * @param {...any[]} args - Additional arguments to pass to the adapter
+     * @return {Promise<M>} A promise that resolves with the retrieved model instance
+     */
     read(id: string | number, ...args: any[]): Promise<M>;
+    /**
+     * @description Updates an existing resource
+     * @summary Updates an existing resource in the REST API using the provided model.
+     * The method prepares the model for the adapter, sends the update request,
+     * and then converts the response back to a model instance.
+     * @param {M} model - The model instance with updated data
+     * @param {...any[]} args - Additional arguments to pass to the adapter
+     * @return {Promise<M>} A promise that resolves with the updated model instance
+     */
     update(model: M, ...args: any[]): Promise<M>;
+    /**
+     * @description Deletes a resource by ID
+     * @summary Removes a resource from the REST API using the provided ID.
+     * The method sends the delete request and converts the response to a model instance.
+     * @param {string|number} id - The identifier of the resource to delete
+     * @param {...any[]} args - Additional arguments to pass to the adapter
+     * @return {Promise<M>} A promise that resolves with the deleted model instance
+     */
     delete(id: string | number, ...args: any[]): Promise<M>;
+    /**
+     * @description Creates multiple resources
+     * @summary Creates multiple resources in the REST API using the provided models.
+     * The method prepares each model for the adapter, sends a bulk create request,
+     * and then converts the responses back to model instances.
+     * @param {M[]} models - The model instances to create
+     * @param {...any[]} args - Additional arguments to pass to the adapter
+     * @return {Promise<M[]>} A promise that resolves with an array of created model instances
+     */
     createAll(models: M[], ...args: any[]): Promise<M[]>;
+    /**
+     * @description Deletes multiple resources by IDs
+     * @summary Removes multiple resources from the REST API using the provided IDs.
+     * The method sends a bulk delete request and converts the responses to model instances.
+     * @param {string[]|number[]} keys - The identifiers of the resources to delete
+     * @param {...any[]} args - Additional arguments to pass to the adapter
+     * @return {Promise<M[]>} A promise that resolves with an array of deleted model instances
+     */
     deleteAll(keys: string[] | number[], ...args: any[]): Promise<M[]>;
+    /**
+     * @description Retrieves multiple resources by IDs
+     * @summary Fetches multiple resources from the REST API using the provided IDs.
+     * The method sends a bulk read request and converts the responses to model instances.
+     * @param {string[]|number[]} keys - The identifiers of the resources to retrieve
+     * @param {...any[]} args - Additional arguments to pass to the adapter
+     * @return {Promise<M[]>} A promise that resolves with an array of retrieved model instances
+     */
     readAll(keys: string[] | number[], ...args: any[]): Promise<M[]>;
+    /**
+     * @description Updates multiple resources
+     * @summary Updates multiple resources in the REST API using the provided models.
+     * The method prepares each model for the adapter, sends a bulk update request,
+     * and then converts the responses back to model instances.
+     * @param {M[]} models - The model instances with updated data
+     * @param {...any[]} args - Additional arguments to pass to the adapter
+     * @return {Promise<M[]>} A promise that resolves with an array of updated model instances
+     */
     updateAll(models: M[], ...args: any[]): Promise<M[]>;
     /**
-     * @summary Registers an {@link Observer}
-     * @param {Observer} observer
-     *
-     * @see {Observable#observe}
+     * @description Registers an observer
+     * @summary Adds an observer to the list of observers that will be notified of changes.
+     * Throws an error if the observer is already registered.
+     * @param {Observer} observer - The observer to register
+     * @return {void}
+     * @throws {InternalError} If the observer is already registered
      */
     observe(observer: Observer): void;
     /**
-     * @summary Unregisters an {@link Observer}
-     * @param {Observer} observer
-     *
-     * @see {Observable#unObserve}
+     * @description Unregisters an observer
+     * @summary Removes an observer from the list of observers.
+     * Throws an error if the observer is not found.
+     * @param {Observer} observer - The observer to unregister
+     * @return {void}
+     * @throws {InternalError} If the observer is not found
      */
     unObserve(observer: Observer): void;
     /**
-     * @summary calls all registered {@link Observer}s to update themselves
-     * @param {any[]} [args] optional arguments to be passed to the {@link Observer#refresh} method
+     * @description Notifies all registered observers
+     * @summary Calls the refresh method on all registered observers to update themselves.
+     * Any errors during observer refresh are logged as warnings but don't stop the process.
+     * @param {...any[]} [args] - Optional arguments to pass to the observer refresh method
+     * @return {Promise<void>} A promise that resolves when all observers have been updated
      */
     updateObservers(...args: any[]): Promise<void>;
 }