@kaspernj/api-maker 1.0.2160 → 1.0.2161

package/build/data-set-to-attributes.js

@@ -1,11 +1,20 @@
+// @ts-check
 import * as inflection from "inflection";
-/** Convert dataset attributes into normalized params. */
+/**
+ * Convert dataset attributes into normalized params.
+ * @typedef {string | number | boolean | null | undefined} DataSetValue
+ */
+/**
+ * Convert dataset attributes into normalized params.
+ * @param {Record<string, DataSetValue>} dataSet
+ * @returns {Record<string, DataSetValue>}
+ */
 export default function dataSetToAttributes(dataSet) {
-    const result = {};
+    const result = /** @type {Record<string, DataSetValue>} */ ({});
     for (const key in dataSet) {
         const dasherizedKey = `data-${inflection.dasherize(inflection.underscore(key))}`;
         result[dasherizedKey] = dataSet[key];
     }
     return result;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1zZXQtdG8tYXR0cmlidXRlcy5qcyIsInNvdXJjZVJvb3QiOiIvc3JjLyIsInNvdXJjZXMiOlsiZGF0YS1zZXQtdG8tYXR0cmlidXRlcy5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssVUFBVSxNQUFNLFlBQVksQ0FBQTtBQUV4Qyx5REFBeUQ7QUFDekQsTUFBTSxDQUFDLE9BQU8sVUFBVSxtQkFBbUIsQ0FBQyxPQUFPO0lBQ2pELE1BQU0sTUFBTSxHQUFHLEVBQUUsQ0FBQTtJQUVqQixLQUFLLE1BQU0sR0FBRyxJQUFJLE9BQU8sRUFBRSxDQUFDO1FBQzFCLE1BQU0sYUFBYSxHQUFHLFFBQVEsVUFBVSxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsQ0FBQTtRQUVoRixNQUFNLENBQUMsYUFBYSxDQUFDLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFBO0lBQ3RDLENBQUM7SUFFRCxPQUFPLE1BQU0sQ0FBQTtBQUNmLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBpbmZsZWN0aW9uIGZyb20gXCJpbmZsZWN0aW9uXCJcblxuLyoqIENvbnZlcnQgZGF0YXNldCBhdHRyaWJ1dGVzIGludG8gbm9ybWFsaXplZCBwYXJhbXMuICovXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBkYXRhU2V0VG9BdHRyaWJ1dGVzKGRhdGFTZXQpIHtcbiAgY29uc3QgcmVzdWx0ID0ge31cblxuICBmb3IgKGNvbnN0IGtleSBpbiBkYXRhU2V0KSB7XG4gICAgY29uc3QgZGFzaGVyaXplZEtleSA9IGBkYXRhLSR7aW5mbGVjdGlvbi5kYXNoZXJpemUoaW5mbGVjdGlvbi51bmRlcnNjb3JlKGtleSkpfWBcblxuICAgIHJlc3VsdFtkYXNoZXJpemVkS2V5XSA9IGRhdGFTZXRba2V5XVxuICB9XG5cbiAgcmV0dXJuIHJlc3VsdFxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1zZXQtdG8tYXR0cmlidXRlcy5qcyIsInNvdXJjZVJvb3QiOiIvc3JjLyIsInNvdXJjZXMiOlsiZGF0YS1zZXQtdG8tYXR0cmlidXRlcy5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBQ1osT0FBTyxLQUFLLFVBQVUsTUFBTSxZQUFZLENBQUE7QUFFeEM7OztHQUdHO0FBRUg7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxPQUFPLFVBQVUsbUJBQW1CLENBQUMsT0FBTztJQUNqRCxNQUFNLE1BQU0sR0FBRywyQ0FBMkMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFBO0lBRS9ELEtBQUssTUFBTSxHQUFHLElBQUksT0FBTyxFQUFFLENBQUM7UUFDMUIsTUFBTSxhQUFhLEdBQUcsUUFBUSxVQUFVLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUMsRUFBRSxDQUFBO1FBRWhGLE1BQU0sQ0FBQyxhQUFhLENBQUMsR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUE7SUFDdEMsQ0FBQztJQUVELE9BQU8sTUFBTSxDQUFBO0FBQ2YsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuaW1wb3J0ICogYXMgaW5mbGVjdGlvbiBmcm9tIFwiaW5mbGVjdGlvblwiXG5cbi8qKlxuICogQ29udmVydCBkYXRhc2V0IGF0dHJpYnV0ZXMgaW50byBub3JtYWxpemVkIHBhcmFtcy5cbiAqIEB0eXBlZGVmIHtzdHJpbmcgfCBudW1iZXIgfCBib29sZWFuIHwgbnVsbCB8IHVuZGVmaW5lZH0gRGF0YVNldFZhbHVlXG4gKi9cblxuLyoqXG4gKiBDb252ZXJ0IGRhdGFzZXQgYXR0cmlidXRlcyBpbnRvIG5vcm1hbGl6ZWQgcGFyYW1zLlxuICogQHBhcmFtIHtSZWNvcmQ8c3RyaW5nLCBEYXRhU2V0VmFsdWU+fSBkYXRhU2V0XG4gKiBAcmV0dXJucyB7UmVjb3JkPHN0cmluZywgRGF0YVNldFZhbHVlPn1cbiAqL1xuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gZGF0YVNldFRvQXR0cmlidXRlcyhkYXRhU2V0KSB7XG4gIGNvbnN0IHJlc3VsdCA9IC8qKiBAdHlwZSB7UmVjb3JkPHN0cmluZywgRGF0YVNldFZhbHVlPn0gKi8gKHt9KVxuXG4gIGZvciAoY29uc3Qga2V5IGluIGRhdGFTZXQpIHtcbiAgICBjb25zdCBkYXNoZXJpemVkS2V5ID0gYGRhdGEtJHtpbmZsZWN0aW9uLmRhc2hlcml6ZShpbmZsZWN0aW9uLnVuZGVyc2NvcmUoa2V5KSl9YFxuXG4gICAgcmVzdWx0W2Rhc2hlcml6ZWRLZXldID0gZGF0YVNldFtrZXldXG4gIH1cblxuICByZXR1cm4gcmVzdWx0XG59XG4iXX0=

package/build/deserializer.d.ts

@@ -1,6 +1,120 @@
+/**
+ * @typedef {string | number | boolean | null | undefined} DeserializablePrimitive
+ * @typedef {object | DeserializablePrimitive | Array<object | DeserializablePrimitive>} DeserializableValue
+ * @typedef {typeof import("./base-model.js").default} DeserializedModelClass
+ * @typedef {import("./base-model.js").default} DeserializedModelInstance
+ */
 /** Deserializes API Maker encoded payloads. */
 export default class ApiMakerDeserializer {
-    /** parse. */
-    static parse(object: any): any;
+    /**
+     * Recursively deserializes one API Maker encoded payload tree.
+     * @param {DeserializableValue} object
+     * @returns {DeserializableValue | Date | DeserializedModelClass | DeserializedModelInstance}
+     */
+    static parse(object: DeserializableValue): DeserializableValue | Date | DeserializedModelClass | DeserializedModelInstance;
 }
+export type DeserializablePrimitive = string | number | boolean | null | undefined;
+export type DeserializableValue = object | DeserializablePrimitive | Array<object | DeserializablePrimitive>;
+export type DeserializedModelClass = typeof import("./base-model.js").default;
+export type DeserializedModelInstance = {
+    abilities: import("./base-model.js").ModelAbilityMap;
+    changes: import("./base-model.js").ModelDataMap;
+    collection: import("./collection.js").default<any>;
+    _identifierKey: string | number;
+    _markedForDestruction: boolean;
+    modelData: import("./base-model.js").ModelDataMap;
+    newRecord: boolean;
+    previousModelData: any;
+    preloadedRelationships: import("./base-model.js").PreloadedRelationshipMap;
+    relationshipsCache: import("./base-model.js").LoadedRelationshipMap;
+    relationships: import("./base-model.js").LoadedRelationshipMap;
+    uniqueKeyValue: number;
+    assignAttributes(newAttributes: ModelDataMap): void;
+    attributes(): ModelDataMap;
+    can(givenAbilityName: string): boolean;
+    clone(): /*elided*/ any;
+    cacheKey(): number | string;
+    localCacheKey(): string;
+    fullCacheKey(): string;
+    create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    destroy(): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    ensureAbilities(listOfAbilities: string[]): Promise<void>;
+    getAttributes(): ModelDataMap;
+    handleResponseError(response: ModelCommandResponse): never;
+    identifierKey(): number | string;
+    isAssociationLoaded(associationName: string): boolean;
+    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+    isAssociationPresent(associationName: string): boolean;
+    ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+    isAttributeChanged(attributeName: string): boolean;
+    isChanged(): boolean;
+    isNewRecord(): boolean;
+    isPersisted(): boolean;
+    savedChangeToAttribute(attributeName: string): boolean;
+    setNewModel(model: /*elided*/ any): void;
+    setNewModelData(model: /*elided*/ any): void;
+    _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    modelClassData(): ModelClassDataType;
+    reload(): Promise<void>;
+    save(): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    _refreshModelFromResponse(response: ModelCommandResponse): void;
+    _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+    updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        response: ModelCommandResponse;
+        model: /*elided*/ any;
+    }>;
+    isValid(): never;
+    isValidOnServer(): Promise<{
+        valid: boolean;
+        errors: ValidationResponseErrors;
+    }>;
+    modelClass(): BaseModelClassType;
+    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+    markForDestruction(): void;
+    markedForDestruction(): boolean;
+    uniqueKey(): number;
+    _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+    readAttribute(attributeName: string): ModelValue | null | undefined;
+    readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+    isAttributeLoaded(attributeName: string): boolean;
+    _isPresent(value: ModelValue | null | undefined): boolean;
+    _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+    _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+    _readPreloadedRelationships(preloaded: {
+        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+    }): void;
+    primaryKey(): number | string;
+};
 //# sourceMappingURL=deserializer.d.ts.map

package/build/deserializer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deserializer.d.ts","sourceRoot":"/src/","sources":["deserializer.js"],"names":[],"mappings":"AAMA,+CAA+C;AAC/C;IACE,aAAa;IACb,+BAyDC;CACF"}
+{"version":3,"file":"deserializer.d.ts","sourceRoot":"/src/","sources":["deserializer.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AAEH,+CAA+C;AAC/C;IACE;;;;OAIG;IACH,qBAHW,mBAAmB,GACjB,mBAAmB,GAAG,IAAI,GAAG,sBAAsB,GAAG,yBAAyB,CA2D3F;CACF;sCAvEY,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS;kCAC5C,MAAM,GAAG,uBAAuB,GAAG,KAAK,CAAC,MAAM,GAAG,uBAAuB,CAAC;qCAC1E,cAAc,iBAAiB,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAsE48zB,CAAC;;;yBAA6O,CAAC;;;;;;;gBAAoc,CAAC;;;;;yBAAm7E,CAAC"}

package/build/deserializer.js

@@ -1,11 +1,22 @@
+// @ts-check
 import { digg } from "diggerize";
 import * as inflection from "inflection"; // eslint-disable-line sort-imports
 import modelClassRequire from "./model-class-require.js";
 import ModelsResponseReader from "./models-response-reader.js"; // eslint-disable-line sort-imports
 import Money from "js-money";
+/**
+ * @typedef {string | number | boolean | null | undefined} DeserializablePrimitive
+ * @typedef {object | DeserializablePrimitive | Array<object | DeserializablePrimitive>} DeserializableValue
+ * @typedef {typeof import("./base-model.js").default} DeserializedModelClass
+ * @typedef {import("./base-model.js").default} DeserializedModelInstance
+ */
 /** Deserializes API Maker encoded payloads. */
 export default class ApiMakerDeserializer {
-    /** parse. */
+    /**
+     * Recursively deserializes one API Maker encoded payload tree.
+     * @param {DeserializableValue} object
+     * @returns {DeserializableValue | Date | DeserializedModelClass | DeserializedModelInstance}
+     */
     static parse(object) {
         if (Array.isArray(object)) {
             return object.map((value) => ApiMakerDeserializer.parse(value));
@@ -62,4 +73,4 @@ export default class ApiMakerDeserializer {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/destroy-error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"destroy-error.d.ts","sourceRoot":"/src/","sources":["destroy-error.js"],"names":[],"mappings":";AAEA,6BAA6B;AAC7B;CAAyC;;;;wBAHjB,mBAAmB"}
+{"version":3,"file":"destroy-error.d.ts","sourceRoot":"/src/","sources":["destroy-error.js"],"names":[],"mappings":";AAGA,6BAA6B;AAC7B;CAAyC;;;;wBAHjB,mBAAmB"}

package/build/destroy-error.js

@@ -1,7 +1,8 @@
+// @ts-check
 import CustomError from "./custom-error.js";
 /** Destroy command error. */
 class DestroyError extends CustomError {
 }
 DestroyError.apiMakerType = "DestroyError";
 export default DestroyError;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzdHJveS1lcnJvci5qcyIsInNvdXJjZVJvb3QiOiIvc3JjLyIsInNvdXJjZXMiOlsiZGVzdHJveS1lcnJvci5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLFdBQVcsTUFBTSxtQkFBbUIsQ0FBQTtBQUUzQyw2QkFBNkI7QUFDN0IsTUFBTSxZQUFhLFNBQVEsV0FBVztDQUFHO0FBRXpDLFlBQVksQ0FBQyxZQUFZLEdBQUcsY0FBYyxDQUFBO0FBRTFDLGVBQWUsWUFBWSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IEN1c3RvbUVycm9yIGZyb20gXCIuL2N1c3RvbS1lcnJvci5qc1wiXG5cbi8qKiBEZXN0cm95IGNvbW1hbmQgZXJyb3IuICovXG5jbGFzcyBEZXN0cm95RXJyb3IgZXh0ZW5kcyBDdXN0b21FcnJvciB7fVxuXG5EZXN0cm95RXJyb3IuYXBpTWFrZXJUeXBlID0gXCJEZXN0cm95RXJyb3JcIlxuXG5leHBvcnQgZGVmYXVsdCBEZXN0cm95RXJyb3JcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzdHJveS1lcnJvci5qcyIsInNvdXJjZVJvb3QiOiIvc3JjLyIsInNvdXJjZXMiOlsiZGVzdHJveS1lcnJvci5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBQ1osT0FBTyxXQUFXLE1BQU0sbUJBQW1CLENBQUE7QUFFM0MsNkJBQTZCO0FBQzdCLE1BQU0sWUFBYSxTQUFRLFdBQVc7Q0FBRztBQUV6QyxZQUFZLENBQUMsWUFBWSxHQUFHLGNBQWMsQ0FBQTtBQUUxQyxlQUFlLFlBQVksQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuaW1wb3J0IEN1c3RvbUVycm9yIGZyb20gXCIuL2N1c3RvbS1lcnJvci5qc1wiXG5cbi8qKiBEZXN0cm95IGNvbW1hbmQgZXJyb3IuICovXG5jbGFzcyBEZXN0cm95RXJyb3IgZXh0ZW5kcyBDdXN0b21FcnJvciB7fVxuXG5EZXN0cm95RXJyb3IuYXBpTWFrZXJUeXBlID0gXCJEZXN0cm95RXJyb3JcIlxuXG5leHBvcnQgZGVmYXVsdCBEZXN0cm95RXJyb3JcbiJdfQ==