@rattus-orm/react-signals/dist/rattus-orm-react-signals-provider.mjs

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

// src/context/rattus-context.tsx
import { contextBootstrap } from "@rattus-orm/core/utils/integrationsHelpers";
import { RattusReactContext } from "@rattus-orm/core/utils/reactIntegrationHelpers";
import React, { useMemo } from "react";
import { reactUseDatabase } from "@rattus-orm/core/utils/reactIntegrationHelpers";
function RattusProvider(props) {
  const createdDatabase = useMemo(
    () => contextBootstrap(props, new ReactSignalsDataProvider()),
    [props, props.database, props.plugins, props.customRepositories, props.connection]
  );
  return /* @__PURE__ */ React.createElement(RattusReactContext.Provider, { value: createdDatabase }, props.children);
}

// src/data-provider/react-signals-data-provider.ts
import { DataProviderHelpers } from "@rattus-orm/core";

// src/data-provider/signal-store.ts
import { signal } from "@preact/signals-react";
var SignalStore = class {
  constructor(initialState = { data: {} }) {
    this.signal = signal(initialState);
  }
  destroy(ids) {
    const newData = {};
    for (const [id, value] of Object.entries(this.peekData())) {
      if (ids.includes(id)) {
        continue;
      }
      newData[id] = value;
    }
    this.fresh(newData);
  }
  flush() {
    this.signal.value = {
      data: {}
    };
  }
  fresh(records) {
    this.signal.value = {
      data: records
    };
  }
  save(records) {
    this.signal.value = {
      data: {
        ...this.peekData(),
        ...records
      }
    };
  }
  getData() {
    return this.signal.value;
  }
  peekData() {
    return this.signal.peek().data;
  }
};

// src/data-provider/react-signals-data-provider.ts
var ReactSignalsDataProvider = class extends DataProviderHelpers {
  constructor() {
    super(...arguments);
    this.storesMap = /* @__PURE__ */ new Map();
  }
  delete(module, ids) {
    this.getSignalStore(module).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(module) {
    this.getSignalStore(module).flush();
  }
  getModuleState(module) {
    return this.getSignalStore(module).getData();
  }
  hasModule(module) {
    return this.storesMap.has(this.getModulePathAsString(module));
  }
  insert(module, records) {
    this.getSignalStore(module).save(records);
  }
  registerConnection() {
  }
  registerModule(path, initialState) {
    const storeId = this.getModulePathAsString(path);
    if (this.storesMap.has(storeId)) {
      return;
    }
    const newStore = new SignalStore(initialState);
    this.storesMap.set(storeId, newStore);
  }
  replace(module, records) {
    this.getSignalStore(module).fresh(records);
  }
  save(module, records) {
    this.getSignalStore(module).save(records);
  }
  update(module, records) {
    this.getSignalStore(module).save(records);
  }
  getModulePathAsString(modulePath) {
    return [].concat(modulePath).join("/");
  }
  getSignalStore(modulePath) {
    const storeId = this.getModulePathAsString(modulePath);
    if (!this.storesMap.has(storeId)) {
      throw new Error(`[ReactSignalsDataProvider] store "${storeId}" does not exists`);
    }
    return this.storesMap.get(storeId);
  }
};

// src/hooks/useRepository.ts
import { useRepositoryForDynamicContext } from "@rattus-orm/core/utils/integrationsHelpers";
function useRepository(model, connection) {
  return useRepositoryForDynamicContext(model, connection);
}
export {
  RattusProvider,
  ReactSignalsDataProvider,
  reactUseDatabase as useDatabase,
  useRepository
};