@kaspernj/api-maker 1.0.446 → 1.0.448

package/build/commands-pool.js

@@ -0,0 +1,195 @@
+import Api from "./api";
+import CommandSubmitData from "./command-submit-data";
+import CustomError from "./custom-error";
+import DestroyError from "./destroy-error";
+import Deserializer from "./deserializer";
+import { dig, digg } from "diggerize";
+import events from "./events";
+import FormDataObjectizer from "form-data-objectizer";
+import RunLast from "./run-last";
+import Serializer from "./serializer";
+import SessionStatusUpdater from "./session-status-updater";
+import ValidationError from "./validation-error";
+import { ValidationErrors } from "./validation-errors";
+const shared = {};
+export default class ApiMakerCommandsPool {
+  static addCommand(data, args = {}) {
+    let pool;
+    if (args.instant) {
+      pool = new ApiMakerCommandsPool();
+    } else {
+      pool = ApiMakerCommandsPool.current();
+    }
+    const promiseResult = pool.addCommand(data);
+    if (args.instant) {
+      pool.flushRunLast.run();
+    } else {
+      pool.flushRunLast.queue();
+    }
+    return promiseResult;
+  }
+  static current() {
+    if (!shared.currentApiMakerCommandsPool) shared.currentApiMakerCommandsPool = new ApiMakerCommandsPool();
+    return shared.currentApiMakerCommandsPool;
+  }
+  static flush() {
+    ApiMakerCommandsPool.current().flush();
+  }
+  constructor() {
+    this.flushCount = 0;
+    this.pool = {};
+    this.poolData = {};
+    this.currentId = 1;
+    this.globalRequestData = {};
+  }
+  addCommand(data) {
+    const stack = Error().stack;
+    return new Promise((resolve, reject) => {
+      const id = this.currentId;
+      this.currentId += 1;
+      const commandType = data.type;
+      const commandName = data.command;
+      const collectionName = data.collectionName;
+      this.pool[id] = {
+        resolve,
+        reject,
+        stack
+      };
+      if (!this.poolData[commandType]) this.poolData[commandType] = {};
+      if (!this.poolData[commandType][collectionName]) this.poolData[commandType][collectionName] = {};
+      if (!this.poolData[commandType][collectionName][commandName]) this.poolData[commandType][collectionName][commandName] = {};
+      let args;
+      if (data.args?.nodeName == "FORM") {
+        const formData = new FormData(data.args);
+        args = FormDataObjectizer.toObject(formData);
+      } else if (data.args instanceof FormData) {
+        args = FormDataObjectizer.toObject(data.args);
+      } else {
+        args = Serializer.serialize(data.args);
+      }
+      this.poolData[commandType][collectionName][commandName][id] = {
+        args,
+        primary_key: data.primaryKey,
+        id
+      };
+    });
+  }
+  commandsCount() {
+    return Object.keys(this.pool);
+  }
+  async sendRequest({
+    commandSubmitData,
+    url
+  }) {
+    let response;
+    for (let i = 0; i < 3; i++) {
+      if (commandSubmitData.getFilesCount() > 0) {
+        response = await Api.requestLocal({
+          path: url,
+          method: "POST",
+          rawData: commandSubmitData.getFormData()
+        });
+      } else {
+        response = await Api.requestLocal({
+          path: url,
+          method: "POST",
+          data: commandSubmitData.getJsonData()
+        });
+      }
+      if (response.success === false && response.type == "invalid_authenticity_token") {
+        console.log("Invalid authenticity token - try again");
+        await SessionStatusUpdater.current().updateSessionStatus();
+        continue;
+      }
+      return response;
+    }
+    throw new Error("Couldnt successfully execute request");
+  }
+  flush = async () => {
+    if (this.commandsCount() == 0) {
+      return;
+    }
+    const currentPool = this.pool;
+    const currentPoolData = this.poolData;
+    this.pool = {};
+    this.poolData = {};
+    this.flushCount++;
+    try {
+      const submitData = {
+        pool: currentPoolData
+      };
+      if (Object.keys(this.globalRequestData).length > 0) submitData.global = this.globalRequestData;
+      const commandSubmitData = new CommandSubmitData(submitData);
+      const url = "/api_maker/commands";
+      const response = await this.sendRequest({
+        commandSubmitData,
+        url
+      });
+      for (const commandId in response.responses) {
+        const commandResponse = response.responses[commandId];
+        const commandResponseData = Deserializer.parse(commandResponse.data);
+        const commandData = currentPool[parseInt(commandId, 10)];
+        const responseType = commandResponse.type;
+        if (commandResponseData && typeof commandResponseData == "object") {
+          const bugReportUrl = dig(commandResponseData, "bug_report_url");
+          if (bugReportUrl) {
+            console.log(`Bug report URL: ${bugReportUrl}`);
+          }
+        }
+        if (responseType == "success") {
+          commandData.resolve(commandResponseData);
+        } else if (responseType == "error") {
+          const error = new CustomError("Command error", {
+            response: commandResponseData
+          });
+          error.stack += "\n";
+          error.stack += commandData.stack.split("\n").slice(1).join("\n");
+          commandData.reject(error);
+        } else if (responseType == "failed") {
+          this.handleFailedResponse(commandData, commandResponseData);
+        } else {
+          throw new Error(`Unhandled response type: ${responseType}`);
+        }
+      }
+    } finally {
+      this.flushCount--;
+    }
+  };
+  handleFailedResponse(commandData, commandResponseData) {
+    let error;
+    if (commandResponseData.error_type == "destroy_error") {
+      error = new DestroyError(`Destroy failed`, {
+        response: commandResponseData
+      });
+    } else if (commandResponseData.error_type == "validation_error") {
+      const validationErrors = new ValidationErrors({
+        model: digg(commandResponseData, "model"),
+        validationErrors: digg(commandResponseData, "validation_errors")
+      });
+      error = new ValidationError(validationErrors, {
+        response: commandResponseData
+      });
+      events.emit("onValidationErrors", validationErrors);
+    } else {
+      let errorMessage;
+      if (!commandResponseData.errors) {
+        errorMessage = "Command failed";
+      }
+      error = new CustomError(errorMessage, {
+        response: commandResponseData
+      });
+    }
+    commandData.reject(error);
+  }
+  isActive() {
+    if (this.commandsCount() > 0) {
+      return true;
+    }
+    if (this.flushCount > 0) {
+      return true;
+    }
+    return false;
+  }
+  flushRunLast = new RunLast(this.flush);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Api","CommandSubmitData","CustomError","DestroyError","Deserializer","dig","digg","events","FormDataObjectizer","RunLast","Serializer","SessionStatusUpdater","ValidationError","ValidationErrors","shared","ApiMakerCommandsPool","addCommand","data","args","pool","instant","current","promiseResult","flushRunLast","run","queue","currentApiMakerCommandsPool","flush","constructor","flushCount","poolData","currentId","globalRequestData","stack","Error","Promise","resolve","reject","id","commandType","type","commandName","command","collectionName","nodeName","formData","FormData","toObject","serialize","primary_key","primaryKey","commandsCount","Object","keys","sendRequest","commandSubmitData","url","response","i","getFilesCount","requestLocal","path","method","rawData","getFormData","getJsonData","success","console","log","updateSessionStatus","currentPool","currentPoolData","submitData","length","global","commandId","responses","commandResponse","commandResponseData","parse","commandData","parseInt","responseType","bugReportUrl","error","split","slice","join","handleFailedResponse","error_type","validationErrors","model","emit","errorMessage","errors","isActive"],"sources":["../src/commands-pool.js"],"sourcesContent":["import Api from \"./api\"\nimport CommandSubmitData from \"./command-submit-data\"\nimport CustomError from \"./custom-error\"\nimport DestroyError from \"./destroy-error\"\nimport Deserializer from \"./deserializer\"\nimport {dig, digg} from \"diggerize\"\nimport events from \"./events\"\nimport FormDataObjectizer from \"form-data-objectizer\"\nimport RunLast from \"./run-last\"\nimport Serializer from \"./serializer\"\nimport SessionStatusUpdater from \"./session-status-updater\"\nimport ValidationError from \"./validation-error\"\nimport {ValidationErrors} from \"./validation-errors\"\n\nconst shared = {}\n\nexport default class ApiMakerCommandsPool {\n  static addCommand(data, args = {}) {\n    let pool\n\n    if (args.instant) {\n      pool = new ApiMakerCommandsPool()\n    } else {\n      pool = ApiMakerCommandsPool.current()\n    }\n\n    const promiseResult = pool.addCommand(data)\n\n    if (args.instant) {\n      pool.flushRunLast.run()\n    } else {\n      pool.flushRunLast.queue()\n    }\n\n    return promiseResult\n  }\n\n  static current() {\n    if (!shared.currentApiMakerCommandsPool) shared.currentApiMakerCommandsPool = new ApiMakerCommandsPool()\n\n    return shared.currentApiMakerCommandsPool\n  }\n\n  static flush() {\n    ApiMakerCommandsPool.current().flush()\n  }\n\n  constructor() {\n    this.flushCount = 0\n    this.pool = {}\n    this.poolData = {}\n    this.currentId = 1\n    this.globalRequestData = {}\n  }\n\n  addCommand(data) {\n    const stack = Error().stack\n\n    return new Promise((resolve, reject) => {\n      const id = this.currentId\n      this.currentId += 1\n\n      const commandType = data.type\n      const commandName = data.command\n      const collectionName = data.collectionName\n\n      this.pool[id] = {resolve, reject, stack}\n\n      if (!this.poolData[commandType]) this.poolData[commandType] = {}\n      if (!this.poolData[commandType][collectionName]) this.poolData[commandType][collectionName] = {}\n      if (!this.poolData[commandType][collectionName][commandName]) this.poolData[commandType][collectionName][commandName] = {}\n\n      let args\n\n      if (data.args?.nodeName == \"FORM\") {\n        const formData = new FormData(data.args)\n\n        args = FormDataObjectizer.toObject(formData)\n      } else if (data.args instanceof FormData) {\n        args = FormDataObjectizer.toObject(data.args)\n      } else {\n        args = Serializer.serialize(data.args)\n      }\n\n      this.poolData[commandType][collectionName][commandName][id] = {\n        args,\n        primary_key: data.primaryKey,\n        id\n      }\n    })\n  }\n\n  commandsCount() {\n    return Object.keys(this.pool)\n  }\n\n  async sendRequest({commandSubmitData, url}) {\n    let response\n\n    for (let i = 0; i < 3; i++) {\n      if (commandSubmitData.getFilesCount() > 0) {\n        response = await Api.requestLocal({path: url, method: \"POST\", rawData: commandSubmitData.getFormData()})\n      } else {\n        response = await Api.requestLocal({path: url, method: \"POST\", data: commandSubmitData.getJsonData()})\n      }\n\n      if (response.success === false && response.type == \"invalid_authenticity_token\") {\n        console.log(\"Invalid authenticity token - try again\")\n        await SessionStatusUpdater.current().updateSessionStatus()\n        continue\n      }\n\n      return response\n    }\n\n    throw new Error(\"Couldnt successfully execute request\")\n  }\n\n  flush = async () => {\n    if (this.commandsCount() == 0) {\n      return\n    }\n\n    const currentPool = this.pool\n    const currentPoolData = this.poolData\n\n    this.pool = {}\n    this.poolData = {}\n    this.flushCount++\n\n    try {\n      const submitData = {pool: currentPoolData}\n\n      if (Object.keys(this.globalRequestData).length > 0)\n        submitData.global = this.globalRequestData\n\n      const commandSubmitData = new CommandSubmitData(submitData)\n      const url = \"/api_maker/commands\"\n      const response = await this.sendRequest({commandSubmitData, url})\n\n      for (const commandId in response.responses) {\n        const commandResponse = response.responses[commandId]\n        const commandResponseData = Deserializer.parse(commandResponse.data)\n        const commandData = currentPool[parseInt(commandId, 10)]\n        const responseType = commandResponse.type\n\n        if (commandResponseData && typeof commandResponseData == \"object\") {\n          const bugReportUrl = dig(commandResponseData, \"bug_report_url\")\n\n          if (bugReportUrl) {\n            console.log(`Bug report URL: ${bugReportUrl}`)\n          }\n        }\n\n        if (responseType == \"success\") {\n          commandData.resolve(commandResponseData)\n        } else if (responseType == \"error\") {\n          const error = new CustomError(\"Command error\", {response: commandResponseData})\n\n          error.stack += \"\\n\"\n          error.stack += commandData.stack.split(\"\\n\").slice(1).join(\"\\n\")\n\n          commandData.reject(error)\n        } else if (responseType == \"failed\") {\n          this.handleFailedResponse(commandData, commandResponseData)\n        } else {\n          throw new Error(`Unhandled response type: ${responseType}`)\n        }\n      }\n    } finally {\n      this.flushCount--\n    }\n  }\n\n  handleFailedResponse(commandData, commandResponseData) {\n    let error\n\n    if (commandResponseData.error_type == \"destroy_error\") {\n      error = new DestroyError(`Destroy failed`, {response: commandResponseData})\n    } else if (commandResponseData.error_type == \"validation_error\") {\n      const validationErrors = new ValidationErrors({\n        model: digg(commandResponseData, \"model\"),\n        validationErrors: digg(commandResponseData, \"validation_errors\")\n      })\n      error = new ValidationError(validationErrors, {response: commandResponseData})\n\n      events.emit(\"onValidationErrors\", validationErrors)\n    } else {\n      let errorMessage\n\n      if (!commandResponseData.errors) { errorMessage = \"Command failed\" }\n\n      error = new CustomError(errorMessage, {response: commandResponseData})\n    }\n\n    commandData.reject(error)\n  }\n\n  isActive() {\n    if (this.commandsCount() > 0) {\n      return true\n    }\n\n    if (this.flushCount > 0) {\n      return true\n    }\n\n    return false\n  }\n\n  flushRunLast = new RunLast(this.flush)\n}\n"],"mappings":"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","ignoreList":[]}

package/build/compose.js

@@ -0,0 +1,9 @@
+export default function apiMakerCompose(wrappedComponentClass, ...funcs) {
+  if (!wrappedComponentClass) throw new Error("No 'wrappedComponentClass' given");
+  let currentComponentClass = wrappedComponentClass;
+  for (const func of funcs) {
+    currentComponentClass = func(currentComponentClass);
+  }
+  return currentComponentClass;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJhcGlNYWtlckNvbXBvc2UiLCJ3cmFwcGVkQ29tcG9uZW50Q2xhc3MiLCJmdW5jcyIsIkVycm9yIiwiY3VycmVudENvbXBvbmVudENsYXNzIiwiZnVuYyJdLCJzb3VyY2VzIjpbIi4uL3NyYy9jb21wb3NlLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIGFwaU1ha2VyQ29tcG9zZSh3cmFwcGVkQ29tcG9uZW50Q2xhc3MsIC4uLmZ1bmNzKSB7XG4gIGlmICghd3JhcHBlZENvbXBvbmVudENsYXNzKSB0aHJvdyBuZXcgRXJyb3IoXCJObyAnd3JhcHBlZENvbXBvbmVudENsYXNzJyBnaXZlblwiKVxuXG4gIGxldCBjdXJyZW50Q29tcG9uZW50Q2xhc3MgPSB3cmFwcGVkQ29tcG9uZW50Q2xhc3NcblxuICBmb3IgKGNvbnN0IGZ1bmMgb2YgZnVuY3MpIHtcbiAgICBjdXJyZW50Q29tcG9uZW50Q2xhc3MgPSBmdW5jKGN1cnJlbnRDb21wb25lbnRDbGFzcylcbiAgfVxuXG4gIHJldHVybiBjdXJyZW50Q29tcG9uZW50Q2xhc3Ncbn1cbiJdLCJtYXBwaW5ncyI6IkFBQUEsZUFBZSxTQUFTQSxlQUFlQSxDQUFDQyxxQkFBcUIsRUFBRSxHQUFHQyxLQUFLLEVBQUU7RUFDdkUsSUFBSSxDQUFDRCxxQkFBcUIsRUFBRSxNQUFNLElBQUlFLEtBQUssQ0FBQyxrQ0FBa0MsQ0FBQztFQUUvRSxJQUFJQyxxQkFBcUIsR0FBR0gscUJBQXFCO0VBRWpELEtBQUssTUFBTUksSUFBSSxJQUFJSCxLQUFLLEVBQUU7SUFDeEJFLHFCQUFxQixHQUFHQyxJQUFJLENBQUNELHFCQUFxQixDQUFDO0VBQ3JEO0VBRUEsT0FBT0EscUJBQXFCO0FBQzlCIiwiaWdub3JlTGlzdCI6W119

package/build/config.js

@@ -0,0 +1,53 @@
+import * as inflection from "inflection";
+const accessors = {
+  breakPoints: {
+    default: [["xxl", 1400], ["xl", 1200], ["lg", 992], ["md", 768], ["sm", 576], ["xs", 0]],
+    required: true
+  },
+  currenciesCollection: {
+    required: true
+  },
+  history: {
+    required: false
+  },
+  host: {
+    required: false
+  },
+  i18n: {
+    required: false
+  },
+  modal: {
+    required: false
+  },
+  routes: {
+    required: false
+  },
+  routeDefinitions: {
+    required: false
+  }
+};
+class ApiMakerConfig {
+  constructor() {
+    if (!globalThis.apiMakerConfigGlobal) globalThis.apiMakerConfigGlobal = {};
+    this.global = globalThis.apiMakerConfigGlobal;
+  }
+}
+for (const accessorName in accessors) {
+  const accessorData = accessors[accessorName];
+  const camelizedAccessor = inflection.camelize(accessorName);
+  ApiMakerConfig.prototype[`set${camelizedAccessor}`] = function (newValue) {
+    this.global[accessorName] = newValue;
+  };
+  ApiMakerConfig.prototype[`get${camelizedAccessor}`] = function (...args) {
+    if (!this.global[accessorName]) {
+      if (accessorData.default) return accessorData.default;
+      if (accessorData.required) throw new Error(`${accessorName} hasn't been set`);
+    }
+    const value = this.global[accessorName];
+    if (typeof value == "function") return value(...args);
+    return value;
+  };
+}
+const apiMakerConfig = new ApiMakerConfig();
+export default apiMakerConfig;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/custom-error.js

@@ -0,0 +1,5 @@
+import BaseError from "./base-error";
+class CustomError extends BaseError {}
+CustomError.apiMakerType = "CustomError";
+export default CustomError;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJCYXNlRXJyb3IiLCJDdXN0b21FcnJvciIsImFwaU1ha2VyVHlwZSJdLCJzb3VyY2VzIjpbIi4uL3NyYy9jdXN0b20tZXJyb3IuanMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IEJhc2VFcnJvciBmcm9tIFwiLi9iYXNlLWVycm9yXCJcblxuY2xhc3MgQ3VzdG9tRXJyb3IgZXh0ZW5kcyBCYXNlRXJyb3Ige31cblxuQ3VzdG9tRXJyb3IuYXBpTWFrZXJUeXBlID0gXCJDdXN0b21FcnJvclwiXG5cbmV4cG9ydCBkZWZhdWx0IEN1c3RvbUVycm9yXG4iXSwibWFwcGluZ3MiOiJBQUFBLE9BQU9BLFNBQVMsTUFBTSxjQUFjO0FBRXBDLE1BQU1DLFdBQVcsU0FBU0QsU0FBUyxDQUFDO0FBRXBDQyxXQUFXLENBQUNDLFlBQVksR0FBRyxhQUFhO0FBRXhDLGVBQWVELFdBQVciLCJpZ25vcmVMaXN0IjpbXX0=

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

@@ -0,0 +1,10 @@
+import * as inflection from "inflection";
+export default function dataSetToAttributes(dataSet) {
+  const result = {};
+  for (const key in dataSet) {
+    const dasherizedKey = `data-${inflection.dasherize(inflection.underscore(key))}`;
+    result[dasherizedKey] = dataSet[key];
+  }
+  return result;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJpbmZsZWN0aW9uIiwiZGF0YVNldFRvQXR0cmlidXRlcyIsImRhdGFTZXQiLCJyZXN1bHQiLCJrZXkiLCJkYXNoZXJpemVkS2V5IiwiZGFzaGVyaXplIiwidW5kZXJzY29yZSJdLCJzb3VyY2VzIjpbIi4uL3NyYy9kYXRhLXNldC10by1hdHRyaWJ1dGVzLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIGluZmxlY3Rpb24gZnJvbSBcImluZmxlY3Rpb25cIlxuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBkYXRhU2V0VG9BdHRyaWJ1dGVzKGRhdGFTZXQpIHtcbiAgY29uc3QgcmVzdWx0ID0ge31cblxuICBmb3IgKGNvbnN0IGtleSBpbiBkYXRhU2V0KSB7XG4gICAgY29uc3QgZGFzaGVyaXplZEtleSA9IGBkYXRhLSR7aW5mbGVjdGlvbi5kYXNoZXJpemUoaW5mbGVjdGlvbi51bmRlcnNjb3JlKGtleSkpfWBcblxuICAgIHJlc3VsdFtkYXNoZXJpemVkS2V5XSA9IGRhdGFTZXRba2V5XVxuICB9XG5cbiAgcmV0dXJuIHJlc3VsdFxufVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUtBLFVBQVUsTUFBTSxZQUFZO0FBRXhDLGVBQWUsU0FBU0MsbUJBQW1CQSxDQUFDQyxPQUFPLEVBQUU7RUFDbkQsTUFBTUMsTUFBTSxHQUFHLENBQUMsQ0FBQztFQUVqQixLQUFLLE1BQU1DLEdBQUcsSUFBSUYsT0FBTyxFQUFFO0lBQ3pCLE1BQU1HLGFBQWEsR0FBRyxRQUFRTCxVQUFVLENBQUNNLFNBQVMsQ0FBQ04sVUFBVSxDQUFDTyxVQUFVLENBQUNILEdBQUcsQ0FBQyxDQUFDLEVBQUU7SUFFaEZELE1BQU0sQ0FBQ0UsYUFBYSxDQUFDLEdBQUdILE9BQU8sQ0FBQ0UsR0FBRyxDQUFDO0VBQ3RDO0VBRUEsT0FBT0QsTUFBTTtBQUNmIiwiaWdub3JlTGlzdCI6W119

package/build/deserializer.js

@@ -0,0 +1,56 @@
+import { digg } from "diggerize";
+import * as inflection from "inflection";
+import modelClassRequire from "./model-class-require";
+import ModelsResponseReader from "./models-response-reader";
+import Money from "js-money";
+export default class ApiMakerDeserializer {
+  static parse(object) {
+    if (Array.isArray(object)) {
+      return object.map(value => ApiMakerDeserializer.parse(value));
+    } else if (object && typeof object == "object") {
+      if (object.api_maker_type == "date") {
+        const date = new Date(digg(object, "value"));
+        date.apiMakerType = "date";
+        return date;
+      } else if (object.api_maker_type == "time") {
+        const date = new Date(digg(object, "value"));
+        date.apiMakerType = "time";
+        return date;
+      } else if (object.api_maker_type == "collection") {
+        // Need to remove type to avoid circular error
+        const {
+          api_maker_type,
+          ...restObject
+        } = object;
+        return ModelsResponseReader.collection(ApiMakerDeserializer.parse(restObject));
+      } else if (object.api_maker_type == "money") {
+        const cents = digg(object, "amount");
+        const currency = digg(object, "currency");
+        return Money.fromInteger(cents, currency);
+      } else if (object.api_maker_type == "model") {
+        const modelClassName = inflection.classify(digg(object, "model_name"));
+        const ModelClass = modelClassRequire(modelClassName);
+        const data = ApiMakerDeserializer.parse(digg(object, "serialized"));
+        const model = new ModelClass({
+          data,
+          isNewRecord: false
+        });
+        return model;
+      } else if (object.api_maker_type == "resource") {
+        const modelClassName = inflection.classify(digg(object, "name"));
+        const ModelClass = modelClassRequire(modelClassName);
+        return ModelClass;
+      } else {
+        const newObject = {};
+        for (const key in object) {
+          const value = object[key];
+          newObject[key] = ApiMakerDeserializer.parse(value);
+        }
+        return newObject;
+      }
+    } else {
+      return object;
+    }
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/destroy-error.js

@@ -0,0 +1,5 @@
+import CustomError from "./custom-error";
+class DestroyError extends CustomError {}
+DestroyError.apiMakerType = "DestroyError";
+export default DestroyError;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJDdXN0b21FcnJvciIsIkRlc3Ryb3lFcnJvciIsImFwaU1ha2VyVHlwZSJdLCJzb3VyY2VzIjpbIi4uL3NyYy9kZXN0cm95LWVycm9yLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBDdXN0b21FcnJvciBmcm9tIFwiLi9jdXN0b20tZXJyb3JcIlxuXG5jbGFzcyBEZXN0cm95RXJyb3IgZXh0ZW5kcyBDdXN0b21FcnJvciB7fVxuXG5EZXN0cm95RXJyb3IuYXBpTWFrZXJUeXBlID0gXCJEZXN0cm95RXJyb3JcIlxuXG5leHBvcnQgZGVmYXVsdCBEZXN0cm95RXJyb3JcbiJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBT0EsV0FBVyxNQUFNLGdCQUFnQjtBQUV4QyxNQUFNQyxZQUFZLFNBQVNELFdBQVcsQ0FBQztBQUV2Q0MsWUFBWSxDQUFDQyxZQUFZLEdBQUcsY0FBYztBQUUxQyxlQUFlRCxZQUFZIiwiaWdub3JlTGlzdCI6W119

package/build/devise.js

@@ -0,0 +1,109 @@
+import CanCan from "./can-can";
+import Deserializer from "./deserializer";
+import { digg } from "diggerize";
+import events from "./events";
+import * as inflection from "inflection";
+import modelClassRequire from "./model-class-require";
+import Services from "./services";
+const shared = {};
+export default class ApiMakerDevise {
+  static callSignOutEvent(args) {
+    events.emit("onDeviseSignOut", {
+      args
+    });
+  }
+  static current() {
+    if (!shared.currentApiMakerDevise) {
+      shared.currentApiMakerDevise = new ApiMakerDevise();
+    }
+    return shared.currentApiMakerDevise;
+  }
+  static events() {
+    return events;
+  }
+  static addUserScope(scope) {
+    const currentMethodName = `current${inflection.camelize(scope)}`;
+    ApiMakerDevise[currentMethodName] = () => ApiMakerDevise.current().getCurrentScope(scope);
+    const isSignedInMethodName = `is${inflection.camelize(scope)}SignedIn`;
+    ApiMakerDevise[isSignedInMethodName] = () => Boolean(ApiMakerDevise.current().getCurrentScope(scope));
+  }
+  static async signIn(username, password, args = {}) {
+    if (!args.scope) args.scope = "user";
+    const postData = {
+      username,
+      password,
+      args
+    };
+    const response = await Services.current().sendRequest("Devise::SignIn", postData);
+    let model = response.model;
+    if (Array.isArray(model)) model = model[0];
+    ApiMakerDevise.updateSession(model);
+    events.emit("onDeviseSignIn", Object.assign({
+      username
+    }, args));
+    return {
+      model,
+      response
+    };
+  }
+  static updateSession(model, args = {}) {
+    if (!args.scope) args.scope = "user";
+    const camelizedScopeName = inflection.camelize(args.scope, true);
+    ApiMakerDevise.current().currents[camelizedScopeName] = model;
+  }
+  hasCurrentScope(scope) {
+    const camelizedScopeName = inflection.camelize(scope, true);
+    return camelizedScopeName in ApiMakerDevise.current().currents;
+  }
+  static setSignedOut(args) {
+    ApiMakerDevise.current().currents[inflection.camelize(args.scope, true)] = null;
+  }
+  static async signOut(args = {}) {
+    if (!args.scope) {
+      args.scope = "user";
+    }
+    const response = await Services.current().sendRequest("Devise::SignOut", {
+      args
+    });
+
+    // Cannot use the class because they would both import each other
+    if (shared.apiMakerSessionStatusUpdater) {
+      shared.apiMakerSessionStatusUpdater.updateSessionStatus();
+    }
+    ApiMakerDevise.setSignedOut(args);
+    ApiMakerDevise.callSignOutEvent(args);
+    return response;
+  }
+  constructor() {
+    this.currents = {};
+  }
+  getCurrentScope(scope) {
+    if (!(scope in this.currents)) {
+      this.currents[scope] = this.loadCurrentScope(scope);
+    }
+    return this.currents[scope];
+  }
+  hasGlobalCurrentScope(scope) {
+    if (globalThis.apiMakerDeviseCurrent && scope in globalThis.apiMakerDeviseCurrent) {
+      return true;
+    }
+    return false;
+  }
+  loadCurrentScope(scope) {
+    if (!this.hasGlobalCurrentScope(scope)) {
+      return null;
+    }
+    const scopeData = globalThis.apiMakerDeviseCurrent[scope];
+    if (!scopeData) return null;
+    const parsedScopeData = Deserializer.parse(scopeData);
+
+    // Might be a collection with preloaded relationships
+    if (Array.isArray(parsedScopeData)) return parsedScopeData[0];
+    const ModelClass = modelClassRequire(scope);
+    const modelInstance = new ModelClass({
+      data: parsedScopeData
+    });
+    return modelInstance;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["CanCan","Deserializer","digg","events","inflection","modelClassRequire","Services","shared","ApiMakerDevise","callSignOutEvent","args","emit","current","currentApiMakerDevise","addUserScope","scope","currentMethodName","camelize","getCurrentScope","isSignedInMethodName","Boolean","signIn","username","password","postData","response","sendRequest","model","Array","isArray","updateSession","Object","assign","camelizedScopeName","currents","hasCurrentScope","setSignedOut","signOut","apiMakerSessionStatusUpdater","updateSessionStatus","constructor","loadCurrentScope","hasGlobalCurrentScope","globalThis","apiMakerDeviseCurrent","scopeData","parsedScopeData","parse","ModelClass","modelInstance","data"],"sources":["../src/devise.js"],"sourcesContent":["import CanCan from \"./can-can\"\nimport Deserializer from \"./deserializer\"\nimport {digg} from \"diggerize\"\nimport events from \"./events\"\nimport * as inflection from \"inflection\"\nimport modelClassRequire from \"./model-class-require\"\nimport Services from \"./services\"\n\nconst shared = {}\n\nexport default class ApiMakerDevise {\n  static callSignOutEvent(args) {\n    events.emit(\"onDeviseSignOut\", {args})\n  }\n\n  static current() {\n    if (!shared.currentApiMakerDevise) {\n      shared.currentApiMakerDevise = new ApiMakerDevise()\n    }\n\n    return shared.currentApiMakerDevise\n  }\n\n  static events() {\n    return events\n  }\n\n  static addUserScope(scope) {\n    const currentMethodName = `current${inflection.camelize(scope)}`\n\n    ApiMakerDevise[currentMethodName] = () => ApiMakerDevise.current().getCurrentScope(scope)\n\n    const isSignedInMethodName = `is${inflection.camelize(scope)}SignedIn`\n\n    ApiMakerDevise[isSignedInMethodName] = () => Boolean(ApiMakerDevise.current().getCurrentScope(scope))\n  }\n\n  static async signIn(username, password, args = {}) {\n    if (!args.scope) args.scope = \"user\"\n\n    const postData = {username, password, args}\n    const response = await Services.current().sendRequest(\"Devise::SignIn\", postData)\n\n    let model = response.model\n\n    if (Array.isArray(model)) model = model[0]\n\n    ApiMakerDevise.updateSession(model)\n    events.emit(\"onDeviseSignIn\", Object.assign({username}, args))\n\n    return {model, response}\n  }\n\n  static updateSession(model, args = {}) {\n    if (!args.scope) args.scope = \"user\"\n\n    const camelizedScopeName = inflection.camelize(args.scope, true)\n\n    ApiMakerDevise.current().currents[camelizedScopeName] = model\n  }\n\n  hasCurrentScope(scope) {\n    const camelizedScopeName = inflection.camelize(scope, true)\n\n    return camelizedScopeName in ApiMakerDevise.current().currents\n  }\n\n  static setSignedOut(args) {\n    ApiMakerDevise.current().currents[inflection.camelize(args.scope, true)] = null\n  }\n\n  static async signOut(args = {}) {\n    if (!args.scope) {\n      args.scope = \"user\"\n    }\n\n    const response = await Services.current().sendRequest(\"Devise::SignOut\", {args})\n\n    // Cannot use the class because they would both import each other\n    if (shared.apiMakerSessionStatusUpdater) {\n      shared.apiMakerSessionStatusUpdater.updateSessionStatus()\n    }\n\n    ApiMakerDevise.setSignedOut(args)\n    ApiMakerDevise.callSignOutEvent(args)\n\n    return response\n  }\n\n  constructor() {\n    this.currents = {}\n  }\n\n  getCurrentScope(scope) {\n    if (!(scope in this.currents)) {\n      this.currents[scope] = this.loadCurrentScope(scope)\n    }\n\n    return this.currents[scope]\n  }\n\n  hasGlobalCurrentScope(scope) {\n    if (globalThis.apiMakerDeviseCurrent && scope in globalThis.apiMakerDeviseCurrent) {\n      return true\n    }\n\n    return false\n  }\n\n  loadCurrentScope(scope) {\n    if (!this.hasGlobalCurrentScope(scope)) {\n      return null\n    }\n\n    const scopeData = globalThis.apiMakerDeviseCurrent[scope]\n\n    if (!scopeData) return null\n\n    const parsedScopeData = Deserializer.parse(scopeData)\n\n    // Might be a collection with preloaded relationships\n    if (Array.isArray(parsedScopeData)) return parsedScopeData[0]\n\n    const ModelClass = modelClassRequire(scope)\n    const modelInstance = new ModelClass({data: parsedScopeData})\n\n    return modelInstance\n  }\n}\n"],"mappings":"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","ignoreList":[]}