@reactionary/fake 0.10.53 → 0.10.54

package/capabilities/store.capability.js

@@ -11,12 +11,17 @@ var __decorateClass = (decorators, target, key, kind) => {
 import {
   Reactionary,
   StoreCapability,
+  StorePaginatedResultSchema,
+  StoreQueryByIdSchema,
   StoreQueryByProximitySchema,
+  StoreQueryForListSchema,
   StoreSchema,
+  error,
   success
 } from "@reactionary/core";
 import * as z from "zod";
 import { base, en, Faker } from "@faker-js/faker";
+import { calcSeed } from "../utilities/seed.js";
 class FakeStoreCapability extends StoreCapability {
   config;
   factory;
@@ -25,26 +30,82 @@ class FakeStoreCapability extends StoreCapability {
     this.config = config;
     this.factory = factory;
   }
-  async queryByProximity(payload) {
+  /**
+   * The countries the fake brand has physical stores in.
+   */
+  getStoreCountries() {
+    return ["DK", "SE", "NO", "FI", "US"];
+  }
+  /**
+   * How many physical stores the seed generates per country.
+   */
+  getStoresPerCountry() {
+    return 3;
+  }
+  /**
+   * The seeded set of physical stores: a fixed number per country, generated
+   * deterministically from the store key.
+   */
+  getSeededStores() {
+    const stores = [];
+    for (const country of this.getStoreCountries()) {
+      for (let i = 1; i <= this.getStoresPerCountry(); i++) {
+        stores.push(this.generateStore(`${country.toLowerCase()}-${i}`, country));
+      }
+    }
+    return stores;
+  }
+  generateStore(key, countryCode) {
     const generator = new Faker({
-      seed: 42,
+      seed: calcSeed(key),
       locale: [en, base]
     });
-    const results = [];
-    for (let i = 0; i < payload.limit; i++) {
-      results.push(
-        this.factory.parseStore(this.context, {
-          identifier: {
-            key: `${i}`
-          },
-          fulfillmentCenter: {
-            key: `${i}`
-          },
-          name: generator.company.name()
-        })
-      );
+    const city = generator.location.city();
+    return this.factory.parseStore(this.context, {
+      identifier: {
+        key
+      },
+      fulfillmentCenter: {
+        key
+      },
+      name: `${generator.company.name()} ${city}`,
+      address: {
+        identifier: { nickName: key },
+        firstName: "",
+        lastName: "",
+        streetAddress: generator.location.streetAddress(),
+        streetNumber: "",
+        city,
+        region: "",
+        postalCode: generator.location.zipCode("####"),
+        countryCode
+      },
+      openingHours: "Mon-Fri 10am-6pm, Sat 10am-3pm"
+    });
+  }
+  async queryByProximity(payload) {
+    return success(this.getSeededStores().slice(0, payload.limit));
+  }
+  async list(payload) {
+    const stores = this.getSeededStores();
+    const { pageNumber, pageSize } = payload.paginationOptions;
+    const startIndex = (pageNumber - 1) * pageSize;
+    return success({
+      pageNumber,
+      pageSize,
+      totalCount: stores.length,
+      totalPages: Math.ceil(stores.length / pageSize),
+      items: stores.slice(startIndex, startIndex + pageSize)
+    });
+  }
+  async getById(payload) {
+    const store = this.getSeededStores().find(
+      (candidate) => candidate.identifier.key === payload.identifier.key
+    );
+    if (!store) {
+      return error({ type: "NotFound", identifier: payload.identifier });
     }
-    return success(results);
+    return success(store);
   }
 }
 __decorateClass([
@@ -53,6 +114,18 @@ __decorateClass([
     outputSchema: z.array(StoreSchema)
   })
 ], FakeStoreCapability.prototype, "queryByProximity", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: StoreQueryForListSchema,
+    outputSchema: StorePaginatedResultSchema
+  })
+], FakeStoreCapability.prototype, "list", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: StoreQueryByIdSchema,
+    outputSchema: StoreSchema
+  })
+], FakeStoreCapability.prototype, "getById", 1);
 export {
   FakeStoreCapability
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/fake",
-  "version": "0.10.53",
+  "version": "0.10.54",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",
@@ -9,7 +9,7 @@
     "url": "git+https://github.com/Solteq/reactionary.git"
   },
   "dependencies": {
-    "@reactionary/core": "0.10.53",
+    "@reactionary/core": "0.10.54",
     "zod": "4.1.9",
     "@faker-js/faker": "^9.8.0"
   },

package/src/capabilities/store.capability.d.ts

@@ -1,4 +1,4 @@
-import type { Cache, RequestContext, Result, StoreFactory, StoreFactoryOutput, StoreFactoryWithOutput, StoreQueryByProximity } from '@reactionary/core';
+import type { Cache, NotFoundError, RequestContext, Result, StoreFactory, StoreFactoryOutput, StoreFactoryWithOutput, StorePaginatedResult, StoreQueryById, StoreQueryByProximity, StoreQueryForList } from '@reactionary/core';
 import { StoreCapability } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import type { FakeStoreFactory } from '../factories/store/store.factory.js';
@@ -6,5 +6,21 @@ export declare class FakeStoreCapability<TFactory extends StoreFactory = FakeSto
     protected config: FakeConfiguration;
     protected factory: StoreFactoryWithOutput<TFactory>;
     constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: StoreFactoryWithOutput<TFactory>);
+    /**
+     * The countries the fake brand has physical stores in.
+     */
+    protected getStoreCountries(): string[];
+    /**
+     * How many physical stores the seed generates per country.
+     */
+    protected getStoresPerCountry(): number;
+    /**
+     * The seeded set of physical stores: a fixed number per country, generated
+     * deterministically from the store key.
+     */
+    protected getSeededStores(): StoreFactoryOutput<TFactory>[];
+    protected generateStore(key: string, countryCode: string): StoreFactoryOutput<TFactory>;
     queryByProximity(payload: StoreQueryByProximity): Promise<Result<StoreFactoryOutput<TFactory>[]>>;
+    list(payload: StoreQueryForList): Promise<Result<StorePaginatedResult>>;
+    getById(payload: StoreQueryById): Promise<Result<StoreFactoryOutput<TFactory>, NotFoundError>>;
 }