@rattus-orm/react-mobx/dist/rattus-orm-react-mobx-provider.js

ORM for your JS/TS apps: react-mobx bindings

"use strict";
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 src_exports = {};
__export(src_exports, {
  RattusProvider: () => RattusProvider,
  ReactMobxDataProvider: () => ReactMobxDataProvider,
  useDatabase: () => import_reactIntegrationHelpers2.reactUseDatabase,
  useRepository: () => useRepository
});
module.exports = __toCommonJS(src_exports);

// src/context/rattus-context.tsx
var import_integrationsHelpers = require("@rattus-orm/core/utils/integrationsHelpers");
var import_reactIntegrationHelpers = require("@rattus-orm/core/utils/reactIntegrationHelpers");
var import_react = __toESM(require("react"));

// src/data-provider/react-mobx-data-provider.ts
var import_core = require("@rattus-orm/core");

// src/mobx/mobx-store.ts
var import_mobx = require("mobx");
var MobxStore = class {
  constructor(initialState) {
    this.state = { data: {} };
    (0, import_mobx.makeObservable)(this, {
      state: import_mobx.observable,
      save: import_mobx.action,
      flush: import_mobx.action,
      fresh: import_mobx.action,
      destroy: import_mobx.action,
      data: import_mobx.computed
    });
    this.state = initialState ?? { data: {} };
  }
  get data() {
    return this.state;
  }
  destroy(ids) {
    ids.forEach((id) => {
      delete this.state.data[id];
    });
  }
  save(records) {
    this.state.data = {
      ...this.state.data,
      ...records
    };
  }
  flush() {
    this.state = {
      data: {}
    };
  }
  fresh(records) {
    this.state = {
      data: records
    };
  }
};

// src/data-provider/react-mobx-data-provider.ts
var ReactMobxDataProvider = class extends import_core.DataProviderHelpers {
  constructor() {
    super(...arguments);
    this.storesMap = /* @__PURE__ */ new Map();
  }
  delete(module2, ids) {
    this.getMobxStore(module2).destroy(ids);
  }
  dump() {
    const result = {};
    for (const storeId of this.storesMap.keys()) {
      const modulePath = storeId.split("/");
      const [connection, moduleName] = modulePath;
      if (!result[connection]) {
        result[connection] = {
          [moduleName]: this.getModuleState(modulePath)
        };
        continue;
      }
      result[connection][moduleName] = this.getModuleState(modulePath);
    }
    return result;
  }
  flush(module2) {
    this.getMobxStore(module2).flush();
  }
  getModuleState(module2) {
    return this.getMobxStore(module2).data;
  }
  hasModule(module2) {
    return this.storesMap.has(this.getModulePathAsString(module2));
  }
  insert(module2, records) {
    this.getMobxStore(module2).save(records);
  }
  registerConnection() {
  }
  registerModule(path, initialState) {
    const storeId = this.getModulePathAsString(path);
    if (this.storesMap.has(storeId)) {
      return;
    }
    const newStore = new MobxStore(initialState);
    this.storesMap.set(storeId, newStore);
  }
  replace(module2, records) {
    this.getMobxStore(module2).fresh(records);
  }
  save(module2, records) {
    this.getMobxStore(module2).save(records);
  }
  update(module2, records) {
    this.getMobxStore(module2).save(records);
  }
  getModulePathAsString(modulePath) {
    return modulePath.join("/");
  }
  getMobxStore(modulePath) {
    const storeId = this.getModulePathAsString(modulePath);
    if (!this.storesMap.has(storeId)) {
      throw new Error(`[ReactMobxDataProvider] store "${storeId}" does not exists`);
    }
    return this.storesMap.get(storeId);
  }
};

// src/context/rattus-context.tsx
var import_reactIntegrationHelpers2 = require("@rattus-orm/core/utils/reactIntegrationHelpers");
function RattusProvider(props) {
  const createdDatabase = (0, import_react.useMemo)(
    () => (0, import_integrationsHelpers.contextBootstrap)(props, new ReactMobxDataProvider()),
    [props, props.database, props.plugins, props.customRepositories, props.connection]
  );
  return /* @__PURE__ */ import_react.default.createElement(import_reactIntegrationHelpers.RattusReactContext.Provider, { value: createdDatabase }, props.children);
}

// src/hooks/useRepository.ts
var import_integrationsHelpers2 = require("@rattus-orm/core/utils/integrationsHelpers");
function useRepository(model, connection) {
  return (0, import_integrationsHelpers2.useRepositoryForDynamicContext)(model, connection);
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  RattusProvider,
  ReactMobxDataProvider,
  useDatabase,
  useRepository
});