@web-ts-toolkit/access-router-client 0.3.0

package/index.js

@@ -0,0 +1,2016 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DataService: () => DataService,
+  Model: () => Model,
+  ModelService: () => ModelService,
+  Service: () => Service,
+  ServiceError: () => ServiceError,
+  createAdapter: () => createAdapter,
+  default: () => index_default,
+  removeItemById: () => removeItemById,
+  replaceItemById: () => replaceItemById,
+  wrapLazyPromise: () => wrapLazyPromise
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/adapter.ts
+var import_axios5 = __toESM(require("axios"));
+var import_utils7 = require("@web-ts-toolkit/utils");
+
+// src/services/model-service.ts
+var import_axios2 = require("axios");
+var import_utils5 = require("@web-ts-toolkit/utils");
+
+// src/types.ts
+var wrapLazyPromise = (promiseFn, meta) => {
+  let promise;
+  const exec = () => {
+    if (!promise) {
+      promise = promiseFn();
+    }
+    return promise;
+  };
+  const prom = {
+    exec,
+    then(onFulfilled, onRejected) {
+      return exec().then(onFulfilled, onRejected);
+    },
+    catch(onRejected) {
+      return exec().catch(onRejected);
+    },
+    finally(onFinally) {
+      return exec().finally(onFinally);
+    },
+    [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+      return "LazyPromise";
+    }
+  };
+  Object.defineProperty(prom, Symbol.toStringTag, {
+    value: "Promise",
+    writable: false,
+    enumerable: false,
+    configurable: true
+  });
+  Object.assign(prom, meta);
+  return prom;
+};
+
+// src/model.ts
+var import_utils = require("@web-ts-toolkit/utils");
+var Model = class _Model {
+  constructor(data, adapter) {
+    this.modifiedPaths = /* @__PURE__ */ new Set();
+    this._snapshot = (0, import_utils.cloneDeep)(data);
+    this.defineHiddenDataProp((0, import_utils.cloneDeep)(data));
+    this.defineHiddenAdapterProp(adapter);
+    this.definePublicDataProps();
+    this.initializeDirtyState();
+  }
+  static create(data, adapter) {
+    return new _Model(data, adapter);
+  }
+  async save(reqConfig) {
+    let result;
+    if (this._data._id) {
+      result = await this._service.update(this._data._id, this.prepareData(), { returningAll: false }, reqConfig);
+    } else {
+      result = await this._service.create(this.prepareData(), null, reqConfig);
+    }
+    if (result.success) {
+      this.updateModel(result.raw);
+      this._snapshot = (0, import_utils.cloneDeep)(this._data);
+      this.modifiedPaths.clear();
+    }
+    return {
+      ...result,
+      data: result.success ? _Model.create(this._data, this._service) : null
+    };
+  }
+  isDirty(path) {
+    return path ? this.modifiedPaths.has(this.normalizePath(String(path))) : this.modifiedPaths.size > 0;
+  }
+  markModified(path) {
+    this.trackModified(String(path));
+    return this;
+  }
+  get(path) {
+    return (0, import_utils.get)(this._data, path);
+  }
+  set(path, value) {
+    const currentValue = (0, import_utils.get)(this._data, path);
+    if (Object.is(currentValue, value)) {
+      return this;
+    }
+    (0, import_utils.set)(this._data, path, value);
+    this.trackModified(path);
+    this.definePublicDataProps();
+    return this;
+  }
+  assign(partial) {
+    const keys = Object.keys(partial);
+    for (let x = 0; x < keys.length; x++) {
+      const key = keys[x];
+      const nextValue = partial[key];
+      if (!Object.is(this._data[key], nextValue)) {
+        this._data[key] = nextValue;
+      }
+    }
+    this.definePublicDataProps();
+    return this;
+  }
+  reset() {
+    this.replaceData(this._snapshot);
+    this.modifiedPaths.clear();
+    return this;
+  }
+  toObject() {
+    return (0, import_utils.cloneDeep)(this._data);
+  }
+  toJSON() {
+    return this.toObject();
+  }
+  // async validate() {}
+  updateModel(data) {
+    (0, import_utils.assign)(this._data, data);
+    this.definePublicDataProps();
+  }
+  replaceData(data) {
+    const nextData = (0, import_utils.cloneDeep)(data);
+    const currentKeys = Object.keys(this._data);
+    for (let x = 0; x < currentKeys.length; x++) {
+      const key = currentKeys[x];
+      if (!Object.prototype.hasOwnProperty.call(nextData, key)) {
+        delete this._data[key];
+      }
+    }
+    (0, import_utils.assign)(this._data, nextData);
+    this.definePublicDataProps();
+  }
+  initializeDirtyState() {
+    if (this._data._id) {
+      return;
+    }
+    const keys = Object.keys(this._data);
+    for (let x = 0; x < keys.length; x++) {
+      const key = keys[x];
+      if (key !== "_id") {
+        this.trackModified(key);
+      }
+    }
+  }
+  prepareData() {
+    return (0, import_utils.omit)((0, import_utils.pick)(this._data, Array.from(this.modifiedPaths).map(String)), ["_id"]);
+  }
+  defineHiddenDataProp(initialValue) {
+    Object.defineProperty(this, "_data", {
+      value: new Proxy(initialValue, {
+        set: (target, key, value) => {
+          const keystr = String(key);
+          if (Object.is(target[key], value)) {
+            return true;
+          }
+          this.trackModified(keystr);
+          target[key] = value;
+          return true;
+        }
+      }),
+      enumerable: false,
+      writable: true,
+      configurable: false
+    });
+  }
+  defineHiddenAdapterProp(initialValue) {
+    Object.defineProperty(this, "_service", {
+      value: initialValue,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  }
+  definePublicDataProps() {
+    const keys = Object.keys(this._data);
+    const keycnt = keys.length;
+    for (let x = 0; x < keycnt; x++) {
+      const key = keys[x];
+      if (key in this) continue;
+      Object.defineProperty(this, key, {
+        enumerable: true,
+        get: () => Object.prototype.hasOwnProperty.call(this._data, key) ? this._data[key] : null,
+        set: (value) => this._data[key] = value
+      });
+    }
+  }
+  trackModified(path) {
+    this.modifiedPaths.add(this.normalizePath(path));
+  }
+  normalizePath(path) {
+    return path.split(".")[0];
+  }
+};
+
+// src/services/service.ts
+var import_axios = require("axios");
+var import_utils3 = require("@web-ts-toolkit/utils");
+
+// src/constants.ts
+var CACHE_HEADER = "x-axios-cache";
+
+// src/helpers.ts
+var import_utils2 = require("@web-ts-toolkit/utils");
+function replaceSubQuery(filter) {
+  if (!(0, import_utils2.isPlainObject)(filter)) return filter;
+  const ret = (0, import_utils2.mapValues)(filter, (val) => {
+    if (val && val.__op && val.__query) {
+      return {
+        $$sq: val.__query
+      };
+    }
+    if ((0, import_utils2.isPlainObject)(val)) {
+      return replaceSubQuery(val);
+    }
+    if (Array.isArray(val)) {
+      return val.map((v) => replaceSubQuery(v));
+    }
+    return val;
+  });
+  return ret;
+}
+function template(templateString, data) {
+  return templateString.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    return data[key] !== void 0 ? data[key] : match;
+  });
+}
+function getWrapContext(url, options, config) {
+  const { queryParams, pathParams } = options ?? {};
+  const finalUrl = pathParams ? template(url, pathParams) : url;
+  if (queryParams && config) config.params = queryParams;
+  return { finalUrl, finalConfig: config };
+}
+
+// src/services/service.ts
+var removeTrailingSlash = (inputString) => inputString.replace(/\/$/, "");
+var removeLeadingSlash = (inputString) => inputString.replace(/^\/+/g, "");
+var readProblemDetail = (value) => {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  if ("detail" in value && typeof value.detail === "string" && value.detail) {
+    return value.detail;
+  }
+  if ("message" in value && typeof value.message === "string" && value.message) {
+    return value.message;
+  }
+  if ("title" in value && typeof value.title === "string" && value.title) {
+    return value.title;
+  }
+  if ("errors" in value && Array.isArray(value.errors)) {
+    for (const item of value.errors) {
+      if (typeof item === "string" && item) {
+        return item;
+      }
+      const nested = readProblemDetail(item);
+      if (nested) {
+        return nested;
+      }
+    }
+  }
+  return void 0;
+};
+var stringifyErrorPayload = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  const detail = readProblemDetail(value);
+  if (detail) {
+    return detail;
+  }
+  if (value == null) {
+    return "";
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+var Service = class {
+  constructor(axios2, basePath) {
+    this._axios = axios2;
+    this._basePath = basePath;
+  }
+  handleSuccess(res, extra = {}) {
+    return { success: true, raw: res.data, status: res.status, headers: res.headers, ...extra };
+  }
+  // See https://axios-http.com/docs/handling_errors
+  handleError(error) {
+    const result = {
+      success: false,
+      raw: null,
+      data: null,
+      message: "",
+      status: 0,
+      headers: {}
+    };
+    if (error.response) {
+      result.status = error.response.status;
+      result.headers = error.response.headers;
+      const responseData = error.response.data;
+      result.raw = responseData;
+      result.data = responseData;
+      result.message = stringifyErrorPayload(responseData);
+    } else if (error.request) {
+      result.message = "The server is not responding";
+    } else {
+      result.message = error.message;
+    }
+    return result;
+  }
+  wrapGet(url, defaultAxiosRequestConfig = {}) {
+    const _url = `${removeTrailingSlash(this._basePath)}/${removeLeadingSlash(url)}`;
+    (0, import_utils3.set)(defaultAxiosRequestConfig, `headers.${CACHE_HEADER}`, "true");
+    return (options, axiosRequestConfig) => {
+      const { finalUrl, finalConfig } = getWrapContext(
+        _url,
+        options,
+        (0, import_axios.mergeConfig)(defaultAxiosRequestConfig, axiosRequestConfig)
+      );
+      return this._axios.get(finalUrl, finalConfig);
+    };
+  }
+  wrapPost(url, defaultAxiosRequestConfig = {}) {
+    const _url = `${removeTrailingSlash(this._basePath)}/${removeLeadingSlash(url)}`;
+    (0, import_utils3.set)(defaultAxiosRequestConfig, `headers.${CACHE_HEADER}`, "false");
+    return (data, options, axiosRequestConfig) => {
+      const { finalUrl, finalConfig } = getWrapContext(
+        _url,
+        options,
+        (0, import_axios.mergeConfig)(defaultAxiosRequestConfig, axiosRequestConfig)
+      );
+      return this._axios.post(finalUrl, data, finalConfig);
+    };
+  }
+  wrapPut(url, defaultAxiosRequestConfig = {}) {
+    const _url = `${removeTrailingSlash(this._basePath)}/${removeLeadingSlash(url)}`;
+    (0, import_utils3.set)(defaultAxiosRequestConfig, `headers.${CACHE_HEADER}`, "false");
+    return (data, options, axiosRequestConfig) => {
+      const { finalUrl, finalConfig } = getWrapContext(
+        _url,
+        options,
+        (0, import_axios.mergeConfig)(defaultAxiosRequestConfig, axiosRequestConfig)
+      );
+      return this._axios.put(finalUrl, data, finalConfig);
+    };
+  }
+  wrapPatch(url, defaultAxiosRequestConfig = {}) {
+    const _url = `${removeTrailingSlash(this._basePath)}/${removeLeadingSlash(url)}`;
+    (0, import_utils3.set)(defaultAxiosRequestConfig, `headers.${CACHE_HEADER}`, "false");
+    return (data, options, axiosRequestConfig) => {
+      const { finalUrl, finalConfig } = getWrapContext(
+        _url,
+        options,
+        (0, import_axios.mergeConfig)(defaultAxiosRequestConfig, axiosRequestConfig)
+      );
+      return this._axios.patch(finalUrl, data, finalConfig);
+    };
+  }
+  wrapDelete(url, defaultAxiosRequestConfig = {}) {
+    const _url = `${removeTrailingSlash(this._basePath)}/${removeLeadingSlash(url)}`;
+    (0, import_utils3.set)(defaultAxiosRequestConfig, `headers.${CACHE_HEADER}`, "false");
+    return (options, axiosRequestConfig) => {
+      const { finalUrl, finalConfig } = getWrapContext(
+        _url,
+        options,
+        (0, import_axios.mergeConfig)(defaultAxiosRequestConfig, axiosRequestConfig)
+      );
+      return this._axios.delete(finalUrl, finalConfig);
+    };
+  }
+  updateHeaders(headers, { ignoreCache }) {
+    const cacheValue = ignoreCache ? "false" : "true";
+    if (!headers) {
+      return { [CACHE_HEADER]: cacheValue };
+    }
+    if (headers instanceof import_axios.AxiosHeaders) {
+      if (headers.has(CACHE_HEADER)) return headers;
+      headers.set(CACHE_HEADER, cacheValue);
+      return headers;
+    }
+    if (CACHE_HEADER in headers) return headers;
+    return {
+      ...headers,
+      [CACHE_HEADER]: cacheValue
+    };
+  }
+};
+var ServiceError = class extends Error {
+  constructor(result) {
+    super(result.message);
+    this.name = "ServiceError";
+    this.success = result.success;
+    this.raw = result.raw;
+    this.data = result.data;
+    this.status = result.status;
+    this.headers = result.headers;
+  }
+};
+
+// src/services/shared.ts
+var import_utils4 = require("@web-ts-toolkit/utils");
+var setDefaultObjectProp = (obj, key, value) => {
+  if (!(0, import_utils4.get)(obj, key)) {
+    (0, import_utils4.set)(obj, key, value);
+  }
+};
+var createResponseHandler = (onSuccess, onFailure, throwOnError) => {
+  const successHandler = onSuccess ?? import_utils4.noop;
+  const failureHandler = onFailure ?? import_utils4.noop;
+  return (res, shouldThrowOnError = throwOnError) => {
+    if (res.success) {
+      successHandler(res);
+      return res;
+    }
+    failureHandler(res);
+    if (shouldThrowOnError) {
+      throw new ServiceError(res);
+    }
+    return res;
+  };
+};
+
+// src/services/model-service.ts
+var ModelService = class extends Service {
+  constructor({ axios: axios2, modelName, basePath, queryPath, mutationPath, onSuccess, onFailure, throwOnError }, defaults) {
+    super(axios2, basePath);
+    this._modelName = modelName;
+    this._queryPath = queryPath;
+    this._mutationPath = mutationPath;
+    this._defaults = defaults ?? {};
+    this._handleCallbacks = createResponseHandler(onSuccess, onFailure, throwOnError);
+    [
+      "listArgs",
+      "listOptions",
+      "listAdvancedArgs",
+      "listAdvancedOptions",
+      "readOptions",
+      "readAdvancedArgs",
+      "readAdvancedOptions",
+      "createOptions",
+      "createAdvancedArgs",
+      "createAdvancedOptions",
+      "updateOptions",
+      "updateAdvancedArgs",
+      "updateAdvancedOptions",
+      "upsertOptions",
+      "upsertAdvancedArgs",
+      "upsertAdvancedOptions"
+    ].forEach((key) => setDefaultObjectProp(this._defaults, key, {}));
+  }
+  list(args, options, axiosRequestConfig) {
+    const {
+      skip = this._defaults.listArgs.skip,
+      limit = this._defaults.listArgs.limit,
+      page = this._defaults.listArgs.page,
+      pageSize = this._defaults.listArgs.pageSize
+    } = args ?? {};
+    const {
+      skim = this._defaults.listOptions.skim ?? true,
+      includePermissions = this._defaults.listOptions.includePermissions ?? false,
+      includeCount = this._defaults.listOptions.includeCount ?? false,
+      includeExtraHeaders = this._defaults.listOptions.includeExtraHeaders ?? false,
+      ignoreCache = this._defaults.listOptions.ignoreCache ?? false,
+      sq
+    } = options ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    reqConfig.headers = this.updateHeaders(reqConfig.headers, { ignoreCache });
+    const result = wrapLazyPromise(
+      () => this._axios.get(
+        this._basePath,
+        (0, import_axios2.mergeConfig)(reqConfig, {
+          params: {
+            skip,
+            limit,
+            page,
+            page_size: pageSize,
+            skim,
+            include_permissions: includePermissions,
+            include_count: includeCount,
+            include_extra_headers: includeExtraHeaders
+          }
+        })
+      ).then(this.handleSuccess).then((result2) => {
+        return this.processListResult(this, result2, { includeCount, includeExtraHeaders });
+      }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+      {
+        __op: "list",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "list",
+          filter: {},
+          args: { skip, limit, page, pageSize },
+          options: {
+            skim,
+            includePermissions,
+            includeCount,
+            includeExtraHeaders
+          },
+          sqOptions: sq
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  listAdvanced(filter, args, options, axiosRequestConfig) {
+    const {
+      populate = this._defaults.listAdvancedArgs.populate,
+      include = this._defaults.listAdvancedArgs.include,
+      sort = this._defaults.listAdvancedArgs.sort,
+      skip = this._defaults.listAdvancedArgs.skip,
+      limit = this._defaults.listAdvancedArgs.limit,
+      page = this._defaults.listAdvancedArgs.page,
+      pageSize = this._defaults.listAdvancedArgs.pageSize,
+      tasks = this._defaults.listAdvancedArgs.tasks
+    } = args ?? {};
+    const select = args?.select ?? this._defaults.listAdvancedArgs.select;
+    const {
+      skim = this._defaults.listAdvancedOptions.skim ?? true,
+      includePermissions = this._defaults.listAdvancedOptions.includePermissions ?? false,
+      includeCount = this._defaults.listAdvancedOptions.includeCount ?? false,
+      includeExtraHeaders = this._defaults.listAdvancedOptions.includeExtraHeaders ?? false,
+      populateAccess = this._defaults.listAdvancedOptions.populateAccess,
+      ignoreCache = this._defaults.listAdvancedOptions.ignoreCache ?? false,
+      sq
+    } = options ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    reqConfig.headers = this.updateHeaders(reqConfig.headers, { ignoreCache });
+    const _filter = replaceSubQuery(filter);
+    const result = wrapLazyPromise(
+      () => this._axios.post(
+        `${this._basePath}/${this._queryPath}`,
+        {
+          filter: _filter,
+          select,
+          sort,
+          populate,
+          include,
+          skip,
+          limit,
+          page,
+          pageSize,
+          tasks,
+          options: {
+            skim,
+            includePermissions,
+            includeCount,
+            includeExtraHeaders,
+            populateAccess
+          }
+        },
+        reqConfig
+      ).then(this.handleSuccess).then((result2) => {
+        return this.processListResult(this, result2, { includeCount, includeExtraHeaders });
+      }).catch(this.handleError).then(
+        (res) => this._handleCallbacks(res, throwOnError)
+      ),
+      {
+        __op: "listAdvanced",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "list",
+          filter: _filter,
+          args: { select, sort, populate, include, skip, limit, page, pageSize, tasks },
+          options: {
+            skim,
+            includePermissions,
+            includeCount,
+            includeExtraHeaders,
+            populateAccess
+          },
+          sqOptions: sq
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  read(identifier, options, axiosRequestConfig) {
+    const {
+      includePermissions = this._defaults.readOptions.includePermissions ?? true,
+      tryList = this._defaults.readOptions.tryList ?? true,
+      ignoreCache = this._defaults.readOptions.ignoreCache ?? false,
+      sq
+    } = options ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    reqConfig.headers = this.updateHeaders(reqConfig.headers, { ignoreCache });
+    const result = wrapLazyPromise(
+      () => this._axios.get(
+        `${this._basePath}/${identifier}`,
+        (0, import_axios2.mergeConfig)(reqConfig, {
+          params: {
+            include_permissions: includePermissions,
+            try_list: tryList
+          }
+        })
+      ).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.success ? Model.create(result2.raw, this) : null;
+        return result2;
+      }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+      {
+        __op: "read",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "read",
+          id: identifier,
+          args: {},
+          options: {
+            includePermissions,
+            tryList
+          },
+          sqOptions: sq
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  readAdvanced(identifier, args, options, axiosRequestConfig) {
+    const {
+      populate = this._defaults.readAdvancedArgs.populate,
+      include = this._defaults.readAdvancedArgs.include,
+      tasks = this._defaults.readAdvancedArgs.tasks
+    } = args ?? {};
+    const select = args?.select ?? this._defaults.readAdvancedArgs.select;
+    const {
+      skim = this._defaults.readAdvancedOptions.skim ?? true,
+      includePermissions = this._defaults.readAdvancedOptions.includePermissions ?? true,
+      tryList = this._defaults.readAdvancedOptions.tryList ?? true,
+      populateAccess = this._defaults.readAdvancedOptions.populateAccess,
+      ignoreCache = this._defaults.readAdvancedOptions.ignoreCache ?? false,
+      sq
+    } = options ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    reqConfig.headers = this.updateHeaders(reqConfig.headers, { ignoreCache });
+    const result = wrapLazyPromise(
+      () => this._axios.post(
+        `${this._basePath}/${this._queryPath}/${identifier}`,
+        {
+          select,
+          populate,
+          include,
+          tasks,
+          options: {
+            skim,
+            includePermissions,
+            tryList,
+            populateAccess
+          }
+        },
+        reqConfig
+      ).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.success ? Model.create(result2.raw, this) : null;
+        return result2;
+      }).catch(this.handleError).then(
+        (res) => this._handleCallbacks(res, throwOnError)
+      ),
+      {
+        __op: "readAdvanced",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "read",
+          id: identifier,
+          args: { select, populate, include, tasks },
+          options: {
+            skim,
+            includePermissions,
+            tryList,
+            populateAccess
+          },
+          sqOptions: sq
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  readAdvancedFilter(filter, args, options, axiosRequestConfig) {
+    const {
+      sort = this._defaults.readAdvancedArgs.sort,
+      populate = this._defaults.readAdvancedArgs.populate,
+      include = this._defaults.readAdvancedArgs.include,
+      tasks = this._defaults.readAdvancedArgs.tasks
+    } = args ?? {};
+    const select = args?.select ?? this._defaults.readAdvancedArgs.select;
+    const {
+      skim = this._defaults.readAdvancedOptions.skim ?? true,
+      includePermissions = this._defaults.readAdvancedOptions.includePermissions ?? true,
+      tryList = this._defaults.readAdvancedOptions.tryList ?? true,
+      populateAccess = this._defaults.readAdvancedOptions.populateAccess,
+      ignoreCache = this._defaults.readAdvancedOptions.ignoreCache ?? false,
+      sq
+    } = options ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    reqConfig.headers = this.updateHeaders(reqConfig.headers, { ignoreCache });
+    const _filter = replaceSubQuery(filter);
+    const result = wrapLazyPromise(
+      () => this._axios.post(
+        `${this._basePath}/${this._queryPath}/__filter`,
+        {
+          filter: _filter,
+          select,
+          sort,
+          populate,
+          include,
+          tasks,
+          options: {
+            skim,
+            includePermissions,
+            tryList,
+            populateAccess
+          }
+        },
+        reqConfig
+      ).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.success ? Model.create(result2.raw, this) : null;
+        return result2;
+      }).catch(this.handleError).then(
+        (res) => this._handleCallbacks(res, throwOnError)
+      ),
+      {
+        __op: "readAdvancedFilter",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "read",
+          filter: _filter,
+          args: { select, sort, populate, include, tasks },
+          options: {
+            skim,
+            includePermissions,
+            tryList,
+            populateAccess
+          },
+          sqOptions: sq
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  new(axiosRequestConfig) {
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    (0, import_utils5.set)(reqConfig, `headers.${CACHE_HEADER}`, "false");
+    const result = wrapLazyPromise(
+      () => this._axios.get(`${this._basePath}/new`, reqConfig).then(this.handleSuccess).then((result2) => {
+        delete result2.raw._id;
+        result2.data = result2.success ? Model.create(result2.raw, this) : null;
+        return result2;
+      }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+      {
+        __op: "new",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "new"
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  create(data, options, axiosRequestConfig) {
+    const { includePermissions = this._defaults.createOptions.includePermissions ?? true } = options ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    (0, import_utils5.set)(reqConfig, `headers.${CACHE_HEADER}`, "false");
+    const result = wrapLazyPromise(
+      () => this._axios.post(this._basePath, data, (0, import_axios2.mergeConfig)(reqConfig, { params: { include_permissions: includePermissions } })).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.success ? Model.create(result2.raw, this) : null;
+        return result2;
+      }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+      {
+        __op: "create",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "create",
+          data,
+          options: {
+            includePermissions
+          }
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  createAdvanced(data, args, options, axiosRequestConfig) {
+    const { populate = this._defaults.createAdvancedArgs.populate, tasks = this._defaults.createAdvancedArgs.tasks } = args ?? {};
+    const select = args?.select ?? this._defaults.createAdvancedArgs.select;
+    const {
+      includePermissions = this._defaults.createAdvancedOptions.includePermissions ?? true,
+      populateAccess = this._defaults.createAdvancedOptions.populateAccess
+    } = options ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    (0, import_utils5.set)(reqConfig, `headers.${CACHE_HEADER}`, "false");
+    const result = wrapLazyPromise(
+      () => this._axios.post(
+        `${this._basePath}/${this._mutationPath}`,
+        { data, select, populate, tasks, options: { includePermissions, populateAccess } },
+        reqConfig
+      ).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.success ? Model.create(result2.raw, this) : null;
+        return result2;
+      }).catch(this.handleError).then(
+        (res) => this._handleCallbacks(res, throwOnError)
+      ),
+      {
+        __op: "createAdvanced",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "create",
+          data,
+          args: { select, populate, tasks },
+          options: {
+            includePermissions,
+            populateAccess
+          }
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  update(identifier, data, options, axiosRequestConfig) {
+    const { returningAll = this._defaults.updateOptions.returningAll ?? true } = options ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    (0, import_utils5.set)(reqConfig, `headers.${CACHE_HEADER}`, "false");
+    const result = wrapLazyPromise(
+      () => this._axios.patch(
+        `${this._basePath}/${identifier}`,
+        data,
+        (0, import_axios2.mergeConfig)(reqConfig, { params: { returning_all: returningAll } })
+      ).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.success ? Model.create(result2.raw, this) : null;
+        return result2;
+      }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+      {
+        __op: "update",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "update",
+          id: identifier,
+          data,
+          options: {
+            returningAll
+          }
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  updateAdvanced(identifier, data, args, options, axiosRequestConfig) {
+    const { populate = this._defaults.updateAdvancedArgs.populate, tasks = this._defaults.updateAdvancedArgs.tasks } = args ?? {};
+    const select = args?.select ?? this._defaults.updateAdvancedArgs.select;
+    const {
+      returningAll = this._defaults.updateAdvancedOptions.returningAll ?? true,
+      includePermissions = this._defaults.updateAdvancedOptions.includePermissions ?? true,
+      populateAccess = this._defaults.updateAdvancedOptions.populateAccess
+    } = options ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    (0, import_utils5.set)(reqConfig, `headers.${CACHE_HEADER}`, "false");
+    const result = wrapLazyPromise(
+      () => this._axios.patch(
+        `${this._basePath}/${this._mutationPath}/${identifier}`,
+        {
+          data,
+          select,
+          populate,
+          tasks,
+          options: { returningAll, includePermissions, populateAccess }
+        },
+        reqConfig
+      ).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.success ? Model.create(result2.raw, this) : null;
+        return result2;
+      }).catch(this.handleError).then(
+        (res) => this._handleCallbacks(res, throwOnError)
+      ),
+      {
+        __op: "updateAdvanced",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "update",
+          id: identifier,
+          data,
+          args: { select, populate, tasks },
+          options: {
+            returningAll,
+            includePermissions,
+            populateAccess
+          }
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  upsert(data, options, axiosRequestConfig) {
+    const { returningAll = this._defaults.upsertOptions.returningAll ?? true } = options ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    (0, import_utils5.set)(reqConfig, `headers.${CACHE_HEADER}`, "false");
+    const result = wrapLazyPromise(
+      () => this._axios.put(this._basePath, data, (0, import_axios2.mergeConfig)(reqConfig, { params: { returning_all: returningAll } })).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.success ? Model.create(result2.raw, this) : null;
+        return result2;
+      }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+      {
+        __op: "upsert",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "upsert",
+          data,
+          options: {
+            returningAll
+          }
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  upsertAdvanced(data, args, options, axiosRequestConfig) {
+    const { populate = this._defaults.upsertAdvancedArgs.populate, tasks = this._defaults.upsertAdvancedArgs.tasks } = args ?? {};
+    const select = args?.select ?? this._defaults.upsertAdvancedArgs.select;
+    const {
+      returningAll = this._defaults.upsertAdvancedOptions.returningAll ?? true,
+      includePermissions = this._defaults.upsertAdvancedOptions.includePermissions ?? true,
+      populateAccess = this._defaults.upsertAdvancedOptions.populateAccess
+    } = options ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    (0, import_utils5.set)(reqConfig, `headers.${CACHE_HEADER}`, "false");
+    const result = wrapLazyPromise(
+      () => this._axios.put(
+        `${this._basePath}/${this._mutationPath}`,
+        {
+          data,
+          select,
+          populate,
+          tasks,
+          options: { returningAll, includePermissions, populateAccess }
+        },
+        reqConfig
+      ).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.success ? Model.create(result2.raw, this) : null;
+        return result2;
+      }).catch(this.handleError).then(
+        (res) => this._handleCallbacks(res, throwOnError)
+      ),
+      {
+        __op: "upsertAdvanced",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "upsert",
+          data,
+          args: { select, populate, tasks },
+          options: {
+            returningAll,
+            includePermissions,
+            populateAccess
+          }
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  delete(identifier, axiosRequestConfig) {
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    (0, import_utils5.set)(reqConfig, `headers.${CACHE_HEADER}`, "false");
+    const result = wrapLazyPromise(
+      () => this._axios.delete(`${this._basePath}/${identifier}`, reqConfig).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.raw;
+        return result2;
+      }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+      {
+        __op: "delete",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "delete",
+          id: identifier
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  distinct(field, axiosRequestConfig) {
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    const result = wrapLazyPromise(
+      () => this._axios.get(`${this._basePath}/distinct/${field}`, reqConfig).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.raw;
+        return result2;
+      }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+      {
+        __op: "distinct",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "distinct",
+          field
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  distinctAdvanced(field, conditions, axiosRequestConfig) {
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    const result = wrapLazyPromise(
+      () => this._axios.post(`${this._basePath}/distinct/${field}`, conditions, reqConfig).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.raw;
+        return result2;
+      }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+      {
+        __op: "distinctAdvanced",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "distinct",
+          field,
+          filter: conditions
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  count(axiosRequestConfig) {
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    const result = wrapLazyPromise(
+      () => this._axios.get(`${this._basePath}/count`, reqConfig).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.raw;
+        return result2;
+      }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+      {
+        __op: "count",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "count"
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  countAdvanced(filter, args, axiosRequestConfig) {
+    const { access } = args ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    const result = wrapLazyPromise(
+      () => this._axios.post(`${this._basePath}/count`, { filter, options: { access } }, reqConfig).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.raw;
+        return result2;
+      }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+      {
+        __op: "countAdvanced",
+        __query: {
+          target: "model",
+          name: this._modelName,
+          model: this._modelName,
+          op: "count",
+          filter,
+          options: { access }
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  id(id) {
+    return {
+      subs: (field) => {
+        const sub = String(field);
+        return {
+          list: (axiosRequestConfig) => {
+            const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+            const result = wrapLazyPromise(
+              () => this._axios.get(
+                `${this._basePath}/${id}/${sub}`,
+                (0, import_axios2.mergeConfig)(reqConfig, {
+                  params: {}
+                })
+              ).then(this.handleSuccess).then((result2) => {
+                result2.totalCount = Array.isArray(result2.raw) ? result2.raw.length : 0;
+                result2.data = [];
+                return result2;
+              }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+              {
+                __op: "listSub",
+                __query: {
+                  target: "model",
+                  name: this._modelName,
+                  model: this._modelName,
+                  op: "subList",
+                  id,
+                  sub,
+                  filter: {},
+                  args: {},
+                  options: {}
+                },
+                __requestConfig: reqConfig,
+                __service: this
+              }
+            );
+            return result;
+          },
+          listAdvanced: (filter, args, axiosRequestConfig) => {
+            const select = args?.select;
+            const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+            const result = wrapLazyPromise(
+              () => this._axios.post(`${this._basePath}/${id}/${sub}/${this._queryPath}`, { filter, select }, reqConfig).then(this.handleSuccess).then((result2) => {
+                result2.totalCount = result2.raw.length;
+                result2.data = [];
+                return result2;
+              }).catch(this.handleError).then(
+                (res) => this._handleCallbacks(
+                  res,
+                  throwOnError
+                )
+              ),
+              {
+                __op: "listAdvancedSub",
+                __query: {
+                  target: "model",
+                  name: this._modelName,
+                  model: this._modelName,
+                  op: "subList",
+                  id,
+                  sub,
+                  filter,
+                  args: { select },
+                  options: {}
+                },
+                __requestConfig: reqConfig,
+                __service: this
+              }
+            );
+            return result;
+          },
+          read: (subId, axiosRequestConfig) => {
+            const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+            const result = wrapLazyPromise(
+              () => this._axios.get(
+                `${this._basePath}/${id}/${sub}/${subId}`,
+                (0, import_axios2.mergeConfig)(reqConfig, {
+                  params: {}
+                })
+              ).then(this.handleSuccess).then((result2) => {
+                result2.data = null;
+                return result2;
+              }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+              {
+                __op: "readSub",
+                __query: {
+                  target: "model",
+                  name: this._modelName,
+                  model: this._modelName,
+                  op: "subRead",
+                  id,
+                  sub,
+                  subId,
+                  args: {},
+                  options: {}
+                },
+                __requestConfig: reqConfig,
+                __service: this
+              }
+            );
+            return result;
+          },
+          readAdvanced: (subId, args, axiosRequestConfig) => {
+            const { select, populate } = args ?? {};
+            const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+            const result = wrapLazyPromise(
+              () => this._axios.post(
+                `${this._basePath}/${id}/${sub}/${subId}/${this._queryPath}`,
+                {
+                  select,
+                  populate
+                },
+                reqConfig
+              ).then(this.handleSuccess).then((result2) => {
+                result2.data = null;
+                return result2;
+              }).catch(this.handleError).then(
+                (res) => this._handleCallbacks(
+                  res,
+                  throwOnError
+                )
+              ),
+              {
+                __op: "readAdvancedSub",
+                __query: {
+                  target: "model",
+                  name: this._modelName,
+                  model: this._modelName,
+                  op: "subRead",
+                  id,
+                  sub,
+                  subId,
+                  args: { select, populate },
+                  options: {}
+                },
+                __requestConfig: reqConfig,
+                __service: this
+              }
+            );
+            return result;
+          },
+          update: (subId, data, axiosRequestConfig) => {
+            const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+            const result = wrapLazyPromise(
+              () => this._axios.patch(`${this._basePath}/${id}/${sub}/${subId}`, data, (0, import_axios2.mergeConfig)(reqConfig, { params: {} })).then(this.handleSuccess).then((result2) => {
+                result2.data = null;
+                return result2;
+              }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+              {
+                __op: "updateSub",
+                __query: {
+                  target: "model",
+                  name: this._modelName,
+                  model: this._modelName,
+                  op: "subUpdate",
+                  id,
+                  sub,
+                  subId,
+                  data,
+                  options: {}
+                },
+                __requestConfig: reqConfig,
+                __service: this
+              }
+            );
+            return result;
+          },
+          bulkUpdate: (data, _options, axiosRequestConfig) => {
+            const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+            const result = wrapLazyPromise(
+              () => this._axios.patch(`${this._basePath}/${id}/${sub}`, data, (0, import_axios2.mergeConfig)(reqConfig, { params: {} })).then(this.handleSuccess).then((result2) => {
+                result2.data = [];
+                return result2;
+              }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+              {
+                __op: "bulkUpdateSub",
+                __query: {
+                  target: "model",
+                  name: this._modelName,
+                  model: this._modelName,
+                  op: "subBulkUpdate",
+                  id,
+                  sub,
+                  data,
+                  options: {}
+                },
+                __requestConfig: reqConfig,
+                __service: this
+              }
+            );
+            return result;
+          },
+          create: (data, axiosRequestConfig) => {
+            const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+            const result = wrapLazyPromise(
+              () => this._axios.post(`${this._basePath}/${id}/${sub}`, data, (0, import_axios2.mergeConfig)(reqConfig, { params: {} })).then(this.handleSuccess).then((result2) => {
+                result2.data = null;
+                return result2;
+              }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+              {
+                __op: "createSub",
+                __query: {
+                  target: "model",
+                  name: this._modelName,
+                  model: this._modelName,
+                  op: "subCreate",
+                  id,
+                  sub,
+                  data,
+                  options: {}
+                },
+                __requestConfig: reqConfig,
+                __service: this
+              }
+            );
+            return result;
+          },
+          delete: (subId, axiosRequestConfig) => {
+            const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+            const result = wrapLazyPromise(
+              () => this._axios.delete(`${this._basePath}/${id}/${sub}/${subId}`, reqConfig).then(this.handleSuccess).then((result2) => {
+                result2.data = null;
+                return result2;
+              }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+              {
+                __op: "deleteSub",
+                __query: {
+                  target: "model",
+                  name: this._modelName,
+                  model: this._modelName,
+                  op: "subDelete",
+                  id,
+                  sub,
+                  subId
+                },
+                __requestConfig: reqConfig,
+                __service: this
+              }
+            );
+            return result;
+          }
+        };
+      },
+      fetch: (args, options, axiosRequestConfig) => {
+        return this.readAdvanced(id, args, options, axiosRequestConfig);
+      }
+    };
+  }
+  processListResult(_this, result, { includeCount, includeExtraHeaders }) {
+    const wrappedRows = (0, import_utils5.get)(result, "raw.data");
+    const wrappedTotalCount = (0, import_utils5.get)(result, "raw.meta.totalCount");
+    if (Array.isArray(wrappedRows)) {
+      const rows = wrappedRows;
+      result.raw = wrappedRows;
+      if (includeCount) {
+        if (includeExtraHeaders) {
+          const totalCount = (0, import_utils5.get)(result, `headers.${"wtt-total-count" /* TotalCount */}`, 0);
+          result.totalCount = Number(totalCount);
+        } else {
+          result.totalCount = Number(wrappedTotalCount ?? rows.length);
+        }
+      }
+    } else if (includeCount) {
+      if (includeExtraHeaders) {
+        const totalCount = (0, import_utils5.get)(result, `headers.${"wtt-total-count" /* TotalCount */}`, 0);
+        result.totalCount = Number(totalCount);
+      } else {
+        result.totalCount = result.raw.count;
+        result.raw = result.raw.rows;
+      }
+    }
+    result.data = result.success ? result.raw.map((item) => Model.create(item, _this)) : [];
+    return result;
+  }
+};
+
+// src/services/data-service.ts
+var import_axios3 = require("axios");
+var import_utils6 = require("@web-ts-toolkit/utils");
+var DataService = class extends Service {
+  constructor({ axios: axios2, dataName, basePath, queryPath, onSuccess, onFailure, throwOnError }, defaults) {
+    super(axios2, basePath);
+    this._dataName = dataName;
+    this._queryPath = queryPath;
+    this._defaults = defaults ?? {};
+    this._handleCallbacks = createResponseHandler(onSuccess, onFailure, throwOnError);
+    [
+      "listArgs",
+      "listOptions",
+      "listAdvancedArgs",
+      "listAdvancedOptions",
+      "readOptions",
+      "readAdvancedArgs",
+      "readAdvancedOptions"
+    ].forEach((key) => setDefaultObjectProp(this._defaults, key, {}));
+  }
+  list(args, options, axiosRequestConfig) {
+    const {
+      skip = this._defaults.listArgs.skip,
+      limit = this._defaults.listArgs.limit,
+      page = this._defaults.listArgs.page,
+      pageSize = this._defaults.listArgs.pageSize
+    } = args ?? {};
+    const {
+      includePermissions = this._defaults.listOptions.includePermissions ?? false,
+      includeCount = this._defaults.listOptions.includeCount ?? false,
+      includeExtraHeaders = this._defaults.listOptions.includeExtraHeaders ?? false,
+      ignoreCache = this._defaults.listOptions.ignoreCache ?? false
+    } = options ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    reqConfig.headers = this.updateHeaders(reqConfig.headers, { ignoreCache });
+    const result = wrapLazyPromise(
+      () => this._axios.get(
+        this._basePath,
+        (0, import_axios3.mergeConfig)(reqConfig, {
+          params: {
+            skip,
+            limit,
+            page,
+            page_size: pageSize,
+            include_permissions: includePermissions,
+            include_count: includeCount,
+            include_extra_headers: includeExtraHeaders
+          }
+        })
+      ).then(this.handleSuccess).then((result2) => {
+        return this.processListResult(result2, { includeCount, includeExtraHeaders });
+      }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+      {
+        __op: "list",
+        __query: {
+          target: "data",
+          name: this._dataName,
+          op: "list",
+          filter: {},
+          args: { skip, limit, page, pageSize },
+          options: {
+            includePermissions,
+            includeCount,
+            includeExtraHeaders
+          }
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  listAdvanced(filter, args, options, axiosRequestConfig) {
+    const {
+      sort = this._defaults.listAdvancedArgs.sort,
+      skip = this._defaults.listAdvancedArgs.skip,
+      limit = this._defaults.listAdvancedArgs.limit,
+      page = this._defaults.listAdvancedArgs.page,
+      pageSize = this._defaults.listAdvancedArgs.pageSize
+    } = args ?? {};
+    const select = args?.select ?? this._defaults.listAdvancedArgs.select;
+    const {
+      includePermissions = this._defaults.listAdvancedOptions.includePermissions ?? false,
+      includeCount = this._defaults.listAdvancedOptions.includeCount ?? false,
+      includeExtraHeaders = this._defaults.listAdvancedOptions.includeExtraHeaders ?? false,
+      ignoreCache = this._defaults.listAdvancedOptions.ignoreCache ?? false
+    } = options ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    reqConfig.headers = this.updateHeaders(reqConfig.headers, { ignoreCache });
+    const _filter = replaceSubQuery(filter);
+    const result = wrapLazyPromise(
+      () => this._axios.post(
+        `${this._basePath}/${this._queryPath}`,
+        {
+          filter: _filter,
+          select,
+          sort,
+          skip,
+          limit,
+          page,
+          pageSize,
+          options: {
+            includePermissions,
+            includeCount,
+            includeExtraHeaders
+          }
+        },
+        reqConfig
+      ).then(this.handleSuccess).then((result2) => {
+        return this.processListResult(result2, { includeCount, includeExtraHeaders });
+      }).catch(this.handleError).then(
+        (res) => this._handleCallbacks(res, throwOnError)
+      ),
+      {
+        __op: "listAdvanced",
+        __query: {
+          target: "data",
+          name: this._dataName,
+          op: "list",
+          filter: _filter,
+          args: { select, sort, skip, limit, page, pageSize },
+          options: {
+            includePermissions,
+            includeCount,
+            includeExtraHeaders
+          }
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  read(identifier, options, axiosRequestConfig) {
+    const {
+      includePermissions = this._defaults.readOptions.includePermissions ?? true,
+      ignoreCache = this._defaults.readOptions.ignoreCache ?? false
+    } = options ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    reqConfig.headers = this.updateHeaders(reqConfig.headers, { ignoreCache });
+    const result = wrapLazyPromise(
+      () => this._axios.get(
+        `${this._basePath}/${identifier}`,
+        (0, import_axios3.mergeConfig)(reqConfig, {
+          params: {
+            include_permissions: includePermissions
+          }
+        })
+      ).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.raw;
+        return result2;
+      }).catch(this.handleError).then((res) => this._handleCallbacks(res, throwOnError)),
+      {
+        __op: "read",
+        __query: {
+          target: "data",
+          name: this._dataName,
+          op: "read",
+          id: identifier,
+          args: {},
+          options: {
+            includePermissions
+          }
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  readAdvanced(identifier, args, options, axiosRequestConfig) {
+    const { ignoreCache = this._defaults.readAdvancedArgs.ignoreCache ?? false } = args ?? {};
+    const select = args?.select ?? this._defaults.readAdvancedArgs.select;
+    const { includePermissions = this._defaults.readAdvancedOptions.includePermissions ?? true } = options ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    reqConfig.headers = this.updateHeaders(reqConfig.headers, { ignoreCache });
+    const result = wrapLazyPromise(
+      () => this._axios.post(`${this._basePath}/${this._queryPath}/${identifier}`, { select }, reqConfig).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.raw;
+        return result2;
+      }).catch(this.handleError).then(
+        (res) => this._handleCallbacks(res, throwOnError)
+      ),
+      {
+        __op: "readAdvanced",
+        __query: {
+          target: "data",
+          name: this._dataName,
+          op: "read",
+          id: identifier,
+          args: { select },
+          options: {
+            includePermissions
+          }
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  readAdvancedFilter(filter, args, options, axiosRequestConfig) {
+    const select = args?.select ?? this._defaults.readAdvancedArgs.select;
+    const {
+      includePermissions = this._defaults.readAdvancedOptions.includePermissions ?? true,
+      ignoreCache = this._defaults.readAdvancedOptions.ignoreCache ?? false
+    } = options ?? {};
+    const { throwOnError, ...reqConfig } = axiosRequestConfig ?? {};
+    reqConfig.headers = this.updateHeaders(reqConfig.headers, { ignoreCache });
+    const _filter = replaceSubQuery(filter);
+    const result = wrapLazyPromise(
+      () => this._axios.post(`${this._basePath}/${this._queryPath}/__filter`, { filter: _filter, select }, reqConfig).then(this.handleSuccess).then((result2) => {
+        result2.data = result2.raw;
+        return result2;
+      }).catch(this.handleError).then(
+        (res) => this._handleCallbacks(res, throwOnError)
+      ),
+      {
+        __op: "readAdvancedFilter",
+        __query: {
+          target: "data",
+          name: this._dataName,
+          op: "read",
+          filter: _filter,
+          args: { select },
+          options: {
+            includePermissions
+          }
+        },
+        __requestConfig: reqConfig,
+        __service: this
+      }
+    );
+    return result;
+  }
+  processListResult(result, { includeCount, includeExtraHeaders }) {
+    const wrappedRows = (0, import_utils6.get)(result, "raw.data");
+    const wrappedTotalCount = (0, import_utils6.get)(result, "raw.meta.totalCount");
+    if (Array.isArray(wrappedRows)) {
+      const rows = wrappedRows;
+      result.raw = wrappedRows;
+      if (includeCount) {
+        if (includeExtraHeaders) {
+          const totalCount = (0, import_utils6.get)(result, `headers.${"wtt-total-count" /* TotalCount */}`, 0);
+          result.totalCount = Number(totalCount);
+        } else {
+          result.totalCount = Number(wrappedTotalCount ?? rows.length);
+        }
+      }
+    } else if (includeCount) {
+      if (includeExtraHeaders) {
+        const totalCount = (0, import_utils6.get)(result, `headers.${"wtt-total-count" /* TotalCount */}`, 0);
+        result.totalCount = Number(totalCount);
+      } else {
+        result.totalCount = result.raw.count;
+        result.raw = result.raw.rows;
+      }
+    }
+    result.data = result.raw;
+    return result;
+  }
+};
+
+// src/services/interceptors.ts
+var import_axios4 = require("axios");
+var SimpleCache = class {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  set(key, value) {
+    this.cache.set(key, value);
+  }
+  get(key) {
+    return this.cache.get(key);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+};
+var normalizeCacheValue = (value) => {
+  if (value == null) return value;
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeCacheValue(item));
+  }
+  if (typeof value === "object") {
+    return Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).reduce((acc, [key, item]) => {
+      acc[key] = normalizeCacheValue(item);
+      return acc;
+    }, {});
+  }
+  return value;
+};
+var IGNORED_CACHE_HEADERS = /* @__PURE__ */ new Set([
+  "accept",
+  "accept-encoding",
+  "cache-control",
+  "connection",
+  "content-length",
+  "content-type",
+  "expires",
+  "host",
+  "pragma",
+  "user-agent"
+]);
+var serializeHeaders = (headers) => {
+  const resolvedHeaders = headers instanceof import_axios4.AxiosHeaders ? headers.toJSON() : headers;
+  const normalizedHeaders = Object.entries(resolvedHeaders ?? {}).filter(([key, value]) => {
+    const normalizedKey = key.toLowerCase();
+    return normalizedKey !== CACHE_HEADER.toLowerCase() && !IGNORED_CACHE_HEADERS.has(normalizedKey) && value !== void 0;
+  }).reduce((acc, [key, value]) => {
+    acc[key.toLowerCase()] = value;
+    return acc;
+  }, {});
+  return JSON.stringify(normalizeCacheValue(normalizedHeaders));
+};
+function generateCacheKey(config) {
+  const key = `${config.baseURL}/${config.url}_${config.method}_${generateParamKey(config.params)}_${generateDataKey(
+    config.data
+  )}_${serializeHeaders(config.headers)}`;
+  return encodeURI(key);
+}
+function generateParamKey(params) {
+  if (!params) return "";
+  return JSON.stringify(normalizeCacheValue(params));
+}
+function generateDataKey(data) {
+  if (!data) return "";
+  return typeof data === "string" ? data : JSON.stringify(normalizeCacheValue(data));
+}
+function useCacheInterceptors(instance, cacheTTL) {
+  const store = new SimpleCache();
+  instance.interceptors.request.use(
+    async (config) => {
+      if (config.headers[CACHE_HEADER] === "false") return config;
+      const key = generateCacheKey(config);
+      const cachedResponse = store.get(key);
+      if (!cachedResponse) {
+        return config;
+      }
+      config.adapter = async (_config) => {
+        return {
+          ...cachedResponse,
+          config: _config,
+          headers: { ...cachedResponse.headers, [CACHE_HEADER]: "true" }
+        };
+      };
+      return config;
+    },
+    (error) => Promise.reject(error)
+  );
+  instance.interceptors.response.use(
+    (response) => {
+      if (response.config.headers[CACHE_HEADER] === "false") return response;
+      const key = generateCacheKey(response.config);
+      store.set(key, response);
+      setTimeout(() => store.delete(key), cacheTTL);
+      return response;
+    },
+    (error) => Promise.reject(error)
+  );
+}
+
+// src/adapter.ts
+var defaultAxiosConfig = Object.freeze({
+  baseURL: "/api",
+  timeout: 0,
+  withCredentials: true,
+  headers: {
+    "Cache-Control": "no-cache",
+    Pragma: "no-cache",
+    Expires: "0"
+  }
+});
+var isModelQuery = (query) => query.target === "model";
+var normalizeConfigValue = (value) => {
+  if (value == null) return value;
+  if (value instanceof import_axios5.AxiosHeaders) {
+    return normalizeConfigValue(value.toJSON());
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeConfigValue(item));
+  }
+  if (typeof value === "object") {
+    return Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).reduce((acc, [key, item]) => {
+      acc[key] = normalizeConfigValue(item);
+      return acc;
+    }, {});
+  }
+  return value;
+};
+var serializeRequestConfig = (config) => JSON.stringify(normalizeConfigValue(config ?? {}));
+function createAdapter(axiosConfig, adapterOptions) {
+  const merged = (0, import_axios5.mergeConfig)(defaultAxiosConfig, axiosConfig ?? {});
+  const instance = import_axios5.default.create(merged);
+  const {
+    rootRouterPath = "root",
+    onSuccess: onSuccessRoot,
+    onFailure: onFailureRoot,
+    throwOnError: throwOnErrorRoot,
+    cacheTTL = 0
+  } = adapterOptions ?? {};
+  if (cacheTTL > 0) useCacheInterceptors(instance, cacheTTL);
+  return Object.freeze({
+    axios: instance,
+    createModelService: ({
+      modelName,
+      basePath,
+      queryPath = "__query",
+      mutationPath = "__mutation",
+      onSuccess,
+      onFailure,
+      throwOnError
+    }, defaults) => {
+      return new ModelService(
+        {
+          axios: instance,
+          modelName,
+          basePath,
+          queryPath,
+          mutationPath,
+          onSuccess: onSuccess ?? onSuccessRoot,
+          onFailure: onFailure ?? onFailureRoot,
+          throwOnError: throwOnError ?? throwOnErrorRoot ?? false
+        },
+        defaults
+      );
+    },
+    createDataService: ({ dataName, basePath, queryPath = "__query", onSuccess, onFailure, throwOnError }, defaults) => {
+      return new DataService(
+        {
+          axios: instance,
+          dataName,
+          basePath,
+          queryPath,
+          onSuccess: onSuccess ?? onSuccessRoot,
+          onFailure: onFailure ?? onFailureRoot,
+          throwOnError: throwOnError ?? throwOnErrorRoot ?? false
+        },
+        defaults
+      );
+    },
+    wrapGet: (url, defaultAxiosRequestConfig = {}) => {
+      (0, import_utils7.set)(defaultAxiosRequestConfig, `headers.${CACHE_HEADER}`, "true");
+      return (options, axiosRequestConfig) => {
+        const { finalUrl, finalConfig } = getWrapContext(
+          url,
+          options,
+          (0, import_axios5.mergeConfig)(defaultAxiosRequestConfig, axiosRequestConfig)
+        );
+        return instance.get(finalUrl, finalConfig);
+      };
+    },
+    wrapPost: (url, defaultAxiosRequestConfig = {}) => {
+      (0, import_utils7.set)(defaultAxiosRequestConfig, `headers.${CACHE_HEADER}`, "false");
+      return (data, options, axiosRequestConfig) => {
+        const { finalUrl, finalConfig } = getWrapContext(
+          url,
+          options,
+          (0, import_axios5.mergeConfig)(defaultAxiosRequestConfig, axiosRequestConfig)
+        );
+        return instance.post(finalUrl, data, finalConfig);
+      };
+    },
+    wrapPut: (url, defaultAxiosRequestConfig = {}) => {
+      (0, import_utils7.set)(defaultAxiosRequestConfig, `headers.${CACHE_HEADER}`, "false");
+      return (data, options, axiosRequestConfig) => {
+        const { finalUrl, finalConfig } = getWrapContext(
+          url,
+          options,
+          (0, import_axios5.mergeConfig)(defaultAxiosRequestConfig, axiosRequestConfig)
+        );
+        return instance.put(finalUrl, data, finalConfig);
+      };
+    },
+    wrapPatch: (url, defaultAxiosRequestConfig = {}) => {
+      (0, import_utils7.set)(defaultAxiosRequestConfig, `headers.${CACHE_HEADER}`, "false");
+      return (data, options, axiosRequestConfig) => {
+        const { finalUrl, finalConfig } = getWrapContext(
+          url,
+          options,
+          (0, import_axios5.mergeConfig)(defaultAxiosRequestConfig, axiosRequestConfig)
+        );
+        return instance.patch(finalUrl, data, finalConfig);
+      };
+    },
+    wrapDelete: (url, defaultAxiosRequestConfig = {}) => {
+      (0, import_utils7.set)(defaultAxiosRequestConfig, `headers.${CACHE_HEADER}`, "false");
+      return (options, axiosRequestConfig) => {
+        const { finalUrl, finalConfig } = getWrapContext(
+          url,
+          options,
+          (0, import_axios5.mergeConfig)(defaultAxiosRequestConfig, axiosRequestConfig)
+        );
+        return instance.delete(finalUrl, finalConfig);
+      };
+    },
+    group: async (...proms) => {
+      let sharedConfig;
+      let sharedConfigKey;
+      const defs = proms.map((prom) => {
+        if (!(0, import_utils7.isEmpty)(prom.__requestConfig)) {
+          const configKey = serializeRequestConfig(prom.__requestConfig);
+          if (sharedConfigKey && sharedConfigKey !== configKey) {
+            throw new Error("Grouped requests must share the same axios request config");
+          }
+          sharedConfig = prom.__requestConfig;
+          sharedConfigKey = configKey;
+        }
+        return prom.__query;
+      });
+      const result = await instance.post(rootRouterPath, defs, sharedConfig ?? {}).then((res) => {
+        return res.data.map(({ result: result2, message, statusCode, op }, index) => {
+          const service = proms[index].__service;
+          const query = proms[index].__query;
+          const success = result2.success;
+          let _raw = success ? result2.data : null;
+          let _data = _raw;
+          if (!success) {
+            _data = null;
+          } else if (isModelQuery(query)) {
+            const modelService = service;
+            if (result2.kind === "list" && Array.isArray(result2.data)) {
+              if (op === "create" && result2.data.length === 1) {
+                _raw = result2.data[0];
+                _data = Model.create(result2.data[0], modelService);
+              } else if (!["distinct", "subList"].includes(op)) {
+                _data = (0, import_utils7.castArray)(result2.data).map((item) => Model.create(item, modelService));
+              }
+            } else if (result2.kind === "single" && ["new", "read", "update", "upsert"].includes(op)) {
+              _data = Model.create(result2.data, modelService);
+            }
+          }
+          return {
+            success,
+            raw: _raw,
+            data: _data,
+            message,
+            status: statusCode,
+            totalCount: result2.success && result2.kind === "list" ? result2.totalCount ?? result2.count ?? 0 : 0,
+            headers: {}
+          };
+        });
+      });
+      return result;
+    }
+  });
+}
+
+// src/utils.ts
+function replaceItemById(items, newItem, options) {
+  const { merge = true } = options ?? {};
+  return items.map((item) => {
+    if (item._id === newItem._id) {
+      return merge ? { ...item, ...newItem } : newItem;
+    }
+    return item;
+  });
+}
+function removeItemById(items, newItem) {
+  return items.filter((item) => {
+    return item._id !== newItem._id;
+  });
+}
+
+// src/index.ts
+var index_default = { createAdapter };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataService,
+  Model,
+  ModelService,
+  Service,
+  ServiceError,
+  createAdapter,
+  removeItemById,
+  replaceItemById,
+  wrapLazyPromise
+});