apixa 0.1.0 → 1.0.0-rc.0

package/README.md

@@ -18,20 +18,63 @@ Working with APIs often means repeating the same patterns across resources and p
 
 Apixa aims to reduce this duplication while preserving TypeScript's type safety and flexibility.
 
-## npm package
+## Installation
 
-The `apixa` package is prepared for publication but has not been published yet. After publication,
-install it with `npm install apixa`. Core has no framework dependency:
+Apixa publishes one npm package: `apixa` (`1.0.0-rc.0`, ESM, Node.js 22+). The RC is prepared
+locally and has not been published. After release, install it with:
+
+```sh
+npm install apixa
+# React applications also install the optional peers:
+npm install apixa react @tanstack/react-query
+```
 
 ```ts
-import { defineApi, defineApis } from "apixa";
+import { defineApi, defineApis, defineMockApi } from "apixa";
+import { MockStore } from "apixa/core";
+import "apixa/mocking/register";
+import { users } from "apixa/mocking/datasets/users";
+import { listDatasets } from "apixa/mocking/node"; // Node-only
+```
+
+```tsx
+import {
+  QueryClient,
+  ApixaProvider,
+  ApixaHydrationBoundary,
+  useResource,
+  useResourceQuery,
+  useResourceMutation,
+} from "apixa/react";
+// Server Components use the server-safe entry:
+import { QueryClient as ServerQueryClient, dehydrate } from "apixa/react/advanced";
 ```
 
-Mocking is included under `apixa/mocking`; named datasets use `apixa/mocking/register` and
-`apixa/mocking/datasets`. For the optional React integration, install `react` and
-`@tanstack/react-query`, then import hooks from `apixa/react` and server-safe helpers from
-`apixa/react/advanced`. The existing scoped `@apixa/*` package entry points remain available
-for current consumers.
+Framework subpaths keep integrations isolated. Root, Core and Mocking imports require neither
+React nor TanStack Query. React and TanStack Query are optional peers, left external to the
+library build; install them only when using `apixa/react`. Missing peers produce the loader's
+module-not-found error when a React entry is imported. Future `apixa/vue` and `apixa/angular`
+subpaths are planned, not implemented.
+
+Core, Mocking, React and shared integration helpers remain private workspace modules. Their
+canonical code is compiled into one distribution with shared runtime chunks. No scoped package
+installation is required. See the [installation guide](./docs/guides/humans/install-apixa.md)
+and [public API contract](./docs/public-api.md).
+
+### Runtime support
+
+| Runtime                                      | Status                                                                                                                     |
+| -------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Node.js 22, 24                               | Supported (CI matrix)                                                                                                      |
+| Modern browsers                              | Supported (verified in Chromium)                                                                                           |
+| Cloudflare Workers                           | `apixa`, `apixa/core`, `apixa/mocking*` (not `/node`) and `apixa/react/advanced`, run in `workerd` without `nodejs_compat` |
+| Vercel Edge Runtime                          | Same entries, run in `edge-runtime`                                                                                        |
+| React 18 / 19, Next.js 15 App Router, Vite 6 | Supported (packed consumers, production and development builds)                                                            |
+| TypeScript 5.5+                              | Declarations checked with 5.5.4 and the latest release, `Bundler` and `NodeNext` resolution                                |
+
+`apixa/mocking/node` reads the file system and is Node-only. Thrown errors keep `error.request`
+(including headers and body) readable but non-enumerable, so logging an error does not print
+credentials.
 
 ## Core Principles
 
@@ -40,7 +83,7 @@ for current consumers.
 - **Convention-driven:** Generate common resource operations where appropriate.
 - **Fully customizable:** Support custom endpoints and override generated behavior.
 - **Framework-agnostic:** Keep the core independent of UI frameworks and data-fetching libraries.
-- **Composable:** Allow additional capabilities through optional packages.
+- **Composable:** Allow additional capabilities through isolated subpaths.
 
 ## Usage (implemented)
 
@@ -120,7 +163,7 @@ Set `defaultOperations: false` to start with no builtins, then enable individual
 groups. `writeOnly: true` filters read defaults. Group precedence and all default wire conventions
 are documented in [docs/conventions.md](docs/conventions.md#selection-order).
 
-Pass `transport` to inject a custom HTTP implementation (used in tests). The default is Fetch, shipped inside `@apixa/core`.
+Pass `transport` to inject a custom HTTP implementation (used in tests). The default is Fetch, shipped inside Core.
 
 ### Request reliability (implemented)
 
@@ -219,7 +262,8 @@ API methods are intended to return native promises, allowing them to work natura
 packages/
   core/             # API definitions and execution
   mocking/          # Local datasets and standalone mock APIs
-  tanstack-query/   # Optional React Query integration
+  react/            # Private React integration
+  internal/shared/  # Private, never published: framework-neutral integration helpers
 datasets/           # Version-controlled JSON fixtures
 examples/
   next/             # Primary frontend playground (Next.js)
@@ -245,7 +289,7 @@ Planned later packages (not created yet): `transport-fetch`, `client`, `server`,
 
 ## Project Status
 
-Apixa is in early development. Last shipped: **v0.11.0**. The v1.0.0 TanStack Query workstream is in progress. `@apixa/core` exposes `defineApi()` with default-first CRUD, reliability, re-callable middleware, and extension seams. `@apixa/mocking` augments Core for resource mocks.
+Apixa is in early development. Last shipped: **v0.11.0**. The v1.0.0 TanStack Query workstream is in progress. Core exposes `defineApi()` with default-first CRUD, reliability, re-callable middleware, and extension seams. Mocking augments Core for resource mocks.
 
 See [versions/v1.0.0/acceptance-criteria.md](./versions/v1.0.0/acceptance-criteria.md) for the active milestone checklist.
 

package/dist/{chunk-QZIU7J3G.js → chunks/chunk-3ZFOEESZ.js}

@@ -1,6 +1,6 @@
 import {
   data_default
-} from "./chunk-A3QU5MFP.js";
+} from "./chunk-SO3IYVYQ.js";
 
 // packages/mocking/src/dataset-modules/products.ts
 var products = data_default;

package/dist/{chunk-QVKMZELC.js → chunks/chunk-6WSJJKM6.js}

@@ -1,6 +1,6 @@
 import {
   data_default
-} from "./chunk-ZSLMMDUX.js";
+} from "./chunk-VACVV4XV.js";
 
 // packages/mocking/src/dataset-modules/orders.ts
 var orders = data_default;

package/dist/{chunk-SIFGLE22.js → chunks/chunk-7U7EGEIJ.js}

@@ -2,9 +2,9 @@ import {
   BUILTIN_CONVENTIONS,
   createIdempotencyKey,
   getOperationMetadata
-} from "./chunk-GWZTJ7LM.js";
+} from "./chunk-RYTQAJRH.js";
 
-// packages/tanstack-query/src/operations.ts
+// packages/internal/shared/src/operations.ts
 var BUILTIN_READ_NAMES = new Set(
   Object.entries(BUILTIN_CONVENTIONS).filter(([, convention]) => convention.access === "read").map(([name]) => name)
 );
@@ -45,12 +45,12 @@ function assertNoFullResponse(args, info) {
   const options = args[info.optionsIndex];
   if (isPlainObject(options) && options.full === true) {
     throw new Error(
-      "Apixa TanStack hooks return raw payloads; full: true needs the Core client directly."
+      "Apixa React hooks return raw payloads; full: true needs the Core client directly."
     );
   }
 }
 
-// packages/tanstack-query/src/keys.ts
+// packages/internal/shared/src/keys.ts
 function createResourceKeys(input) {
   const root = [...input.scope ?? [], ...input.queryKey];
   return {
@@ -65,7 +65,12 @@ function createResourceKeys(input) {
   };
 }
 
-// packages/tanstack-query/src/query-options.ts
+// packages/react/src/keys.ts
+function createResourceKeys2(input) {
+  return createResourceKeys(input);
+}
+
+// packages/react/src/query-options.ts
 import {
   infiniteQueryOptions,
   queryOptions
@@ -105,7 +110,7 @@ function buildResourceQueryOptions(resource, options) {
   }
   const staticArgs = Array.isArray(args) ? args : query === void 0 ? void 0 : info.optionsIndex === null ? [{ query }] : withOptions([], info, { query });
   if (staticArgs) assertNoFullResponse(staticArgs, info);
-  const keys = createResourceKeys({ queryKey, scope });
+  const keys = createResourceKeys2({ queryKey, scope });
   const identity = keyParts ?? normalizeIdentity(staticArgs ?? [], info);
   let generatedKey;
   if (operation === "getAll") {
@@ -215,7 +220,7 @@ function buildResourceInfiniteQueryOptions(resource, options) {
       `infinite.query needs Core's RequestOptions slot; ${operation} has a signature Core does not own \u2014 use infinite.args.`
     );
   }
-  const keys = createResourceKeys({ queryKey, scope });
+  const keys = createResourceKeys2({ queryKey, scope });
   const { query: pageQuery, args: pageArgs, initialPageParam, maxPages } = infinite;
   return infiniteQueryOptions({
     ...nativeOptions,
@@ -251,7 +256,7 @@ function prefetchResourceInfiniteQuery(client, resource, options) {
   });
 }
 
-// packages/tanstack-query/src/query-helpers.ts
+// packages/react/src/query-helpers.ts
 var INHERITED = ["staleTime", "gcTime", "retry", "retryDelay", "networkMode", "meta"];
 function createQueryHelpers(resource, client, keys, current) {
   const observed = () => {
@@ -354,8 +359,8 @@ function assertInfiniteData(value) {
   }
 }
 
-// packages/tanstack-query/src/query-controller.ts
-function createResourceQueryController(resource, config, keys = createResourceKeys(config)) {
+// packages/react/src/query-controller.ts
+function createResourceQueryController(resource, config, keys = createResourceKeys2(config)) {
   const root = { queryKey: config.queryKey, scope: config.scope };
   const listOptions = (overrides = {}) => buildResourceQueryOptions(resource, {
     ...overrides,
@@ -407,7 +412,7 @@ function createResourceQueryController(resource, config, keys = createResourceKe
   };
 }
 
-// packages/tanstack-query/src/optimistic.ts
+// packages/react/src/optimistic.ts
 function inFlightFetches(queries) {
   const out = [];
   for (const query of queries) {
@@ -543,7 +548,7 @@ var OptimisticLayers = class _OptimisticLayers {
   }
 };
 
-// packages/tanstack-query/src/mutation-store.ts
+// packages/react/src/mutation-store.ts
 import {
   MutationObserver
 } from "@tanstack/react-query";
@@ -776,9 +781,32 @@ function withIdempotencyKey(resource, name, info, args, keys) {
   return withOptions(args, info, { idempotencyKey: key });
 }
 
+// packages/react/src/query-client.ts
+import {
+  QueryClient as TanStackQueryClient
+} from "@tanstack/react-query";
+var QueryClient = class extends TanStackQueryClient {
+  constructor(config = {}) {
+    const { staleTime, gcTime, retry, networkMode, meta, defaultOptions, ...native } = config;
+    const shorthand = { staleTime, gcTime, retry, networkMode, meta };
+    for (const key of Object.keys(shorthand))
+      if (shorthand[key] === void 0) delete shorthand[key];
+    const hasShorthand = Object.keys(shorthand).length > 0;
+    super(
+      hasShorthand ? {
+        ...native,
+        defaultOptions: {
+          ...defaultOptions,
+          queries: { ...shorthand, ...defaultOptions?.queries }
+        }
+      } : { ...native, ...defaultOptions ? { defaultOptions } : {} }
+    );
+  }
+};
+
 export {
   describeOperations,
-  createResourceKeys,
+  createResourceKeys2 as createResourceKeys,
   createResourceQueryOptions,
   buildResourceQueryOptions,
   createResourceInfiniteQueryOptions,
@@ -790,5 +818,6 @@ export {
   OptimisticLayers,
   ResourceMutationStore,
   validateConfig,
-  applyInvalidation
+  applyInvalidation,
+  QueryClient
 };

package/dist/chunks/chunk-BRBSHKI5.js

@@ -0,0 +1,360 @@
+import {
+  BUILTIN_CONVENTIONS,
+  MockError,
+  MockStore,
+  applyResourceSliceToListResult,
+  expandOperations,
+  runBuiltin
+} from "./chunk-RYTQAJRH.js";
+import {
+  InvalidSliceError,
+  MockApiError,
+  catalog,
+  isDatasetId,
+  listDatasetIds
+} from "./chunk-JM47QQH6.js";
+
+// packages/mocking/src/mock-types.ts
+var MOCK_BUILTINS = [
+  "getAll",
+  "getById",
+  "getBySlug",
+  "getMany",
+  "getBy",
+  "findFirst",
+  "search",
+  "exists",
+  "count",
+  "create",
+  "update",
+  "patch",
+  "upsert",
+  "delete",
+  "createMany",
+  "deleteMany"
+];
+
+// packages/mocking/src/resource.ts
+var CODES = {
+  MOCK_NOT_FOUND: "NOT_FOUND",
+  MOCK_DUPLICATE_ID: "DUPLICATE_ID",
+  MOCK_INVALID_INPUT: "INVALID_INPUT",
+  MOCK_UNSUPPORTED: "INVALID_CONFIG",
+  MOCK_LOAD: "UNKNOWN_DATASET"
+};
+function translate(error) {
+  if (error instanceof MockError) {
+    const code = error.code === "MOCK_INVALID_INPUT" && PAGING_MESSAGE.test(error.message) ? "INVALID_PAGINATION" : CODES[error.code] ?? "INVALID_INPUT";
+    const translated = new MockApiError(code, error.message);
+    translated.cause = error;
+    throw translated;
+  }
+  throw error;
+}
+var PAGING_MESSAGE = /: (page|pageSize|cursor) must be/;
+function createResource(name, type, options) {
+  const label = `Mock resource "${name}"`;
+  const entry = catalog[type];
+  const source = {
+    label,
+    idKey: entry.idKey,
+    load: async () => (await entry.load()).default,
+    // Catalog datasets are module-cached and never mutated: no private snapshot needed.
+    seed: options.seed,
+    immutable: true
+  };
+  const store = new MockStore(source);
+  const pagination = options.pagination === true ? "page" : options.pagination || void 0;
+  const fail = (code, message) => new MockApiError(code, `${label}: ${message}`);
+  const use = (fn) => async (...args) => {
+    try {
+      await store.ready();
+      return await fn(...args);
+    } catch (error) {
+      return translate(error);
+    }
+  };
+  const run = (intent) => async (...args) => {
+    try {
+      const built = intent(...args);
+      const { data } = await runBuiltin(store, source, built, pagination);
+      return built.op === "delete" || built.op === "deleteMany" ? void 0 : data;
+    } catch (error) {
+      return translate(error);
+    }
+  };
+  const getAllFn = run((query) => ({ op: "getAll", query }));
+  const builtins = {
+    // `slice` caps the list result (like Core); the store keeps every record.
+    getAll: async (query) => applyResourceSliceToListResult(await getAllFn(query), options.slice),
+    getById: run((id) => ({ op: "getById", id })),
+    getBySlug: run((slug) => ({ op: "getBySlug", slug })),
+    getMany: run((ids) => ({ op: "getMany", ids })),
+    getBy: run((field, value) => ({ op: "getBy", field, value })),
+    findFirst: run((query) => ({ op: "findFirst", query })),
+    search: run((query) => ({ op: "search", query })),
+    exists: run((id) => ({ op: "exists", id })),
+    count: run((query) => ({ op: "count", query })),
+    create: run((body) => ({ op: "create", body })),
+    update: run((id, body) => ({ op: "update", id, body })),
+    patch: run((id, body) => ({ op: "patch", id, body })),
+    upsert: run((id, body) => ({ op: "upsert", id, body })),
+    delete: run((id) => ({ op: "delete", id })),
+    createMany: run((body) => ({ op: "createMany", body })),
+    deleteMany: run((body) => ({ op: "deleteMany", body }))
+  };
+  const ctx = {
+    idKey: entry.idKey,
+    rows: async () => {
+      await store.ready().catch(translate);
+      return store.liveRows();
+    },
+    fail,
+    defaults: {
+      getAll: use(() => store.list()),
+      getById: use((id) => store.get(id)),
+      create: use((input) => store.create(input)),
+      update: use((id, input) => store.update(id, input)),
+      patch: use((id, input) => store.patch(id, input)),
+      delete: use((id) => store.delete(id))
+    }
+  };
+  const custom = (fn) => async (...args) => {
+    try {
+      return await fn(ctx, ...args);
+    } finally {
+      store.reindex();
+    }
+  };
+  const resource = {};
+  for (const [opName, definition] of Object.entries(options.operations)) {
+    if (typeof definition === "function") {
+      resource[opName] = custom(definition);
+    } else if (MOCK_BUILTINS.includes(opName)) {
+      resource[opName] = builtins[opName];
+    }
+  }
+  return resource;
+}
+
+// packages/mocking/src/slice.ts
+function isPlainSliceRange(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).every((k) => k === "start" || k === "end");
+}
+function assertSliceConfig(slice, label) {
+  if (typeof slice === "number") {
+    if (!Number.isInteger(slice) || slice < 0) {
+      throw new InvalidSliceError(
+        `${label}: slice must be a non-negative integer (got ${String(slice)}).`
+      );
+    }
+    return;
+  }
+  if (!isPlainSliceRange(slice)) {
+    throw new InvalidSliceError(
+      `${label}: slice must be a non-negative integer or { start, end }.`
+    );
+  }
+  const { start, end } = slice;
+  if (typeof start !== "number" || !Number.isInteger(start) || start < 0) {
+    throw new InvalidSliceError(
+      `${label}: slice.start must be a non-negative integer (got ${String(start)}).`
+    );
+  }
+  if (typeof end !== "number" || !Number.isInteger(end) || end < 0) {
+    throw new InvalidSliceError(
+      `${label}: slice.end must be a non-negative integer (got ${String(end)}).`
+    );
+  }
+  if (end < start) {
+    throw new InvalidSliceError(
+      `${label}: slice.end (${end}) must not be before slice.start (${start}).`
+    );
+  }
+}
+
+// packages/mocking/src/mock-api.ts
+var SELECTION_KEYS = ["defaultOperations", "readOnly", "writeOnly", "operationGroups"];
+var ROOT_OPTIONS = ["resources", ...SELECTION_KEYS];
+var RESOURCE_OPTIONS = ["type", "slice", "seed", "pagination", "operations", ...SELECTION_KEYS];
+var GROUPS = ["read", "write", "many", "extended"];
+var EXPECTED_SHAPE = 'defineMockApi() expects { resources: { users: { type: "users-mock" } } } (or the shorthand { users: "users-mock" }).';
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isRootForm(config) {
+  const { resources } = config;
+  if (!isPlainObject(resources)) return false;
+  return typeof resources.type !== "string";
+}
+function assertSettings(settings, label) {
+  for (const key of ["defaultOperations", "readOnly", "writeOnly"]) {
+    const value = settings[key];
+    if (value !== void 0 && typeof value !== "boolean") {
+      throw new MockApiError(
+        "INVALID_CONFIG",
+        `${label}: ${key} must be a boolean (got ${String(value)}).`
+      );
+    }
+  }
+  if (settings.readOnly === true && settings.writeOnly === true) {
+    throw new MockApiError(
+      "INVALID_CONFIG",
+      `${label}: readOnly and writeOnly cannot both be true.`
+    );
+  }
+  const groups = settings.operationGroups;
+  if (groups === void 0) return;
+  if (!isPlainObject(groups)) {
+    throw new MockApiError("INVALID_CONFIG", `${label}: operationGroups must be an object.`);
+  }
+  for (const [group, choice] of Object.entries(groups)) {
+    if (!GROUPS.includes(group)) {
+      throw new MockApiError(
+        "INVALID_CONFIG",
+        `${label}: unknown operation group "${group}". Supported groups: ${GROUPS.join(", ")}.`
+      );
+    }
+    if (choice !== void 0 && typeof choice !== "boolean") {
+      throw new MockApiError(
+        "INVALID_CONFIG",
+        `${label}: operationGroups.${group} must be a boolean (got ${String(choice)}).`
+      );
+    }
+  }
+}
+function assertOperations(operations, label) {
+  if (operations === void 0) return;
+  if (!isPlainObject(operations)) {
+    throw new MockApiError(
+      "INVALID_CONFIG",
+      `${label}: operations must be an object of { name: true | false | function }.`
+    );
+  }
+  for (const [name, value] of Object.entries(operations)) {
+    if (value === void 0 || value === false || typeof value === "function") continue;
+    if (value === true) {
+      if (Object.hasOwn(BUILTIN_CONVENTIONS, name)) continue;
+      throw new MockApiError(
+        "INVALID_CONFIG",
+        `${label}: unknown builtin operation "${name}". \`true\` only enables a builtin; give a custom operation a function.`
+      );
+    }
+    throw new MockApiError(
+      "INVALID_CONFIG",
+      `${label}: operation "${name}" must be true, false, or a function. HTTP forms ({ method, path, \u2026 }) are not supported by a standalone mock.`
+    );
+  }
+}
+function assertSeed(seed, label) {
+  if (!isPlainObject(seed)) {
+    throw new MockApiError("INVALID_CONFIG", `${label}: seed must be { limit?, offset? }.`);
+  }
+  for (const [key, value] of Object.entries(seed)) {
+    if (key !== "limit" && key !== "offset") {
+      throw new MockApiError(
+        "INVALID_CONFIG",
+        `${label}: seed has unknown option "${key}". Supported: limit, offset.`
+      );
+    }
+    if (value !== void 0 && (typeof value !== "number" || !Number.isInteger(value) || value < 0)) {
+      throw new MockApiError(
+        "INVALID_CONFIG",
+        `${label}: seed.${key} must be a non-negative integer (got ${String(value)}).`
+      );
+    }
+  }
+}
+function assertResource(name, resource) {
+  const label = `Mock resource "${name}"`;
+  if (!isPlainObject(resource)) {
+    throw new MockApiError(
+      "INVALID_CONFIG",
+      `${label} must be a dataset id string or an object like { type: "users-mock" }.`
+    );
+  }
+  for (const key of Object.keys(resource)) {
+    if (!RESOURCE_OPTIONS.includes(key)) {
+      throw new MockApiError(
+        "INVALID_CONFIG",
+        `${label} has unsupported option "${key}". Supported options: ${RESOURCE_OPTIONS.join(", ")}.`
+      );
+    }
+  }
+  const { type, slice, seed, pagination, operations } = resource;
+  if (!isDatasetId(type)) {
+    throw new MockApiError(
+      "UNKNOWN_DATASET",
+      `${label}: ${type === void 0 ? 'missing "type"' : `unknown dataset ${JSON.stringify(type)}`}. Available: ${listDatasetIds().join(", ")}.`
+    );
+  }
+  if (slice !== void 0) assertSliceConfig(slice, label);
+  if (seed !== void 0) assertSeed(seed, label);
+  if (pagination !== void 0 && typeof pagination !== "boolean" && pagination !== "page" && pagination !== "cursor") {
+    throw new MockApiError(
+      "INVALID_CONFIG",
+      `${label}: pagination must be true, false, "page" or "cursor" (got ${String(pagination)}).`
+    );
+  }
+  assertSettings(resource, label);
+  assertOperations(operations, label);
+}
+function pickSettings(source) {
+  const out = {};
+  for (const key of SELECTION_KEYS) {
+    if (source[key] !== void 0) out[key] = source[key];
+  }
+  return out;
+}
+function mergeSettings(root, resource) {
+  const merged = { ...root, ...resource };
+  if (root.operationGroups || resource.operationGroups) {
+    merged.operationGroups = { ...root.operationGroups, ...resource.operationGroups };
+  }
+  return merged;
+}
+function defineMockApi(config) {
+  if (!isPlainObject(config)) throw new MockApiError("INVALID_CONFIG", EXPECTED_SHAPE);
+  let root = {};
+  let resources;
+  if (isRootForm(config)) {
+    for (const key of Object.keys(config)) {
+      if (!ROOT_OPTIONS.includes(key)) {
+        throw new MockApiError(
+          "INVALID_CONFIG",
+          `defineMockApi() has unsupported option "${key}". Supported options: ${ROOT_OPTIONS.join(", ")}.`
+        );
+      }
+    }
+    assertSettings(config, "defineMockApi()");
+    root = pickSettings(config);
+    resources = config.resources;
+  } else {
+    resources = config;
+  }
+  const entries = Object.entries(resources);
+  if (entries.length === 0) {
+    throw new MockApiError("INVALID_CONFIG", "defineMockApi() needs at least one resource.");
+  }
+  const api = {};
+  for (const [name, input] of entries) {
+    const resource = typeof input === "string" ? { type: input } : input;
+    assertResource(name, resource);
+    const raw = resource;
+    const settings = mergeSettings(root, pickSettings(raw));
+    api[name] = createResource(name, resource.type, {
+      slice: resource.slice,
+      seed: resource.seed,
+      pagination: resource.pagination,
+      operations: expandOperations(
+        resource.operations,
+        settings
+      )
+    });
+  }
+  return api;
+}
+
+export {
+  defineMockApi
+};

package/dist/{chunk-IAQ5YOVE.js → chunks/chunk-D2GA433L.js}

@@ -1,6 +1,6 @@
 import {
   data_default
-} from "./chunk-DGSIZXRI.js";
+} from "./chunk-YZ7TR6HL.js";
 
 // packages/mocking/src/dataset-modules/companies.ts
 var companies = data_default;

package/dist/{chunk-6ZX7GAWG.js → chunks/chunk-I5JYOAUR.js}

@@ -1,6 +1,6 @@
 import {
   data_default
-} from "./chunk-QY5YMHHN.js";
+} from "./chunk-3RDQXC6Q.js";
 
 // packages/mocking/src/dataset-modules/comments.ts
 var comments = data_default;