@reactionary/provider-fake 0.0.27

package/README.md

@@ -0,0 +1,7 @@
+# Fake
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build provider-fake` to build the library.

package/index.js

@@ -0,0 +1,766 @@
+// core/src/cache/redis-cache.ts
+import { Redis } from "@upstash/redis";
+
+// core/src/providers/base.provider.ts
+var BaseProvider = class {
+  constructor(schema, querySchema, mutationSchema) {
+    this.schema = schema;
+    this.querySchema = querySchema;
+    this.mutationSchema = mutationSchema;
+  }
+  /**
+   * Validates that the final domain model constructed by the provider
+   * fulfills the schema as defined. This will throw an exception.
+   */
+  assert(value) {
+    return this.schema.parse(value);
+  }
+  /**
+   * Creates a new model entity based on the schema defaults.
+   */
+  newModel() {
+    return this.schema.parse({});
+  }
+  /**
+   * Retrieves a set of entities matching the list of queries. The size of
+   * the resulting list WILL always match the size of the query list. The
+   * result list will never contain nulls or undefined. The order
+   * of the results will match the order of the queries.
+   */
+  async query(queries, session) {
+    const results = await this.fetch(queries, session);
+    for (const result of results) {
+      this.assert(result);
+    }
+    return results;
+  }
+  /**
+   * Executes the listed mutations in order and returns the final state
+   * resulting from that set of operations.
+   */
+  async mutate(mutations, session) {
+    const result = await this.process(mutations, session);
+    this.assert(result);
+    return result;
+  }
+};
+
+// core/src/providers/identity.provider.ts
+var IdentityProvider = class extends BaseProvider {
+};
+
+// core/src/providers/product.provider.ts
+var ProductProvider = class extends BaseProvider {
+};
+
+// core/src/providers/search.provider.ts
+var SearchProvider = class extends BaseProvider {
+};
+
+// core/src/schemas/capabilities.schema.ts
+import { z } from "zod";
+var CapabilitiesSchema = z.looseInterface({
+  product: z.boolean(),
+  search: z.boolean(),
+  analytics: z.boolean(),
+  identity: z.boolean(),
+  cart: z.boolean(),
+  inventory: z.boolean(),
+  price: z.boolean()
+});
+
+// core/src/schemas/session.schema.ts
+import { z as z4 } from "zod";
+
+// core/src/schemas/models/identity.model.ts
+import { z as z3 } from "zod";
+
+// core/src/schemas/models/base.model.ts
+import { z as z2 } from "zod";
+var CacheInformationSchema = z2.looseInterface({
+  hit: z2.boolean().default(false),
+  key: z2.string().default("")
+});
+var MetaSchema = z2.looseInterface({
+  cache: CacheInformationSchema.default(() => CacheInformationSchema.parse({})),
+  placeholder: z2.boolean().default(false).describe("Whether or not the entity exists in a remote system, or is a default placeholder.")
+});
+var BaseModelSchema = z2.looseInterface({
+  meta: MetaSchema.default(() => MetaSchema.parse({}))
+});
+
+// core/src/schemas/models/identity.model.ts
+var IdentityTypeSchema = z3.enum(["Anonymous", "Guest", "Registered"]);
+var IdentitySchema = BaseModelSchema.extend({
+  id: z3.string().default(""),
+  type: IdentityTypeSchema.default("Anonymous"),
+  token: z3.string().optional(),
+  issued: z3.coerce.date().default(/* @__PURE__ */ new Date()),
+  expiry: z3.coerce.date().default(/* @__PURE__ */ new Date())
+});
+
+// core/src/schemas/session.schema.ts
+var SessionSchema = z4.looseObject({
+  id: z4.string(),
+  identity: IdentitySchema.default(() => IdentitySchema.parse({}))
+});
+
+// core/src/schemas/models/cart.model.ts
+import { z as z6 } from "zod";
+
+// core/src/schemas/models/identifiers.model.ts
+import { z as z5 } from "zod";
+var FacetIdentifierSchema = z5.looseInterface({
+  key: z5.string().default("").nonoptional()
+});
+var FacetValueIdentifierSchema = z5.looseInterface({
+  facet: FacetIdentifierSchema.default(() => FacetIdentifierSchema.parse({})),
+  key: z5.string().default("")
+});
+var SKUIdentifierSchema = z5.looseInterface({
+  key: z5.string().default("").nonoptional()
+});
+var ProductIdentifierSchema = z5.looseInterface({
+  key: z5.string().default("")
+});
+var SearchIdentifierSchema = z5.looseInterface({
+  term: z5.string().default(""),
+  page: z5.number().default(0),
+  pageSize: z5.number().default(20),
+  facets: z5.array(FacetValueIdentifierSchema.required()).default(() => [])
+});
+var CartIdentifierSchema = z5.looseInterface({
+  key: z5.string().default("")
+});
+var CartItemIdentifierSchema = z5.looseInterface({
+  key: z5.string().default("")
+});
+var PriceIdentifierSchema = z5.looseInterface({
+  sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({}))
+});
+
+// core/src/schemas/models/cart.model.ts
+var CartItemSchema = z6.looseInterface({
+  identifier: CartItemIdentifierSchema.default(() => CartItemIdentifierSchema.parse({})),
+  product: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
+  quantity: z6.number().default(0)
+});
+var CartSchema = BaseModelSchema.extend({
+  identifier: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({})),
+  items: z6.array(CartItemSchema).default(() => [])
+});
+
+// core/src/schemas/models/currency.model.ts
+import { z as z7 } from "zod";
+var CurrencySchema = z7.enum([
+  "AED",
+  "AFN",
+  "ALL",
+  "AMD",
+  "ANG",
+  "AOA",
+  "ARS",
+  "AUD",
+  "AWG",
+  "AZN",
+  "BAM",
+  "BBD",
+  "BDT",
+  "BGN",
+  "BHD",
+  "BIF",
+  "BMD",
+  "BND",
+  "BOB",
+  "BOV",
+  "BRL",
+  "BSD",
+  "BTN",
+  "BWP",
+  "BYN",
+  "BZD",
+  "CAD",
+  "CDF",
+  "CHE",
+  "CHF",
+  "CHW",
+  "CLF",
+  "CLP",
+  "CNY",
+  "COP",
+  "COU",
+  "CRC",
+  "CUC",
+  "CUP",
+  "CVE",
+  "CZK",
+  "DJF",
+  "DKK",
+  "DOP",
+  "DZD",
+  "EGP",
+  "ERN",
+  "ETB",
+  "EUR",
+  "FJD",
+  "FKP",
+  "GBP",
+  "GEL",
+  "GHS",
+  "GIP",
+  "GMD",
+  "GNF",
+  "GTQ",
+  "GYD",
+  "HKD",
+  "HNL",
+  "HRK",
+  "HTG",
+  "HUF",
+  "IDR",
+  "ILS",
+  "INR",
+  "IQD",
+  "IRR",
+  "ISK",
+  "JMD",
+  "JOD",
+  "JPY",
+  "KES",
+  "KGS",
+  "KHR",
+  "KMF",
+  "KPW",
+  "KRW",
+  "KWD",
+  "KYD",
+  "KZT",
+  "LAK",
+  "LBP",
+  "LKR",
+  "LRD",
+  "LSL",
+  "LYD",
+  "MAD",
+  "MDL",
+  "MGA",
+  "MKD",
+  "MMK",
+  "MNT",
+  "MOP",
+  "MRU",
+  "MUR",
+  "MVR",
+  "MWK",
+  "MXN",
+  "MXV",
+  "MYR",
+  "MZN",
+  "NAD",
+  "NGN",
+  "NIO",
+  "NOK",
+  "NPR",
+  "NZD",
+  "OMR",
+  "PAB",
+  "PEN",
+  "PGK",
+  "PHP",
+  "PKR",
+  "PLN",
+  "PYG",
+  "QAR",
+  "RON",
+  "RSD",
+  "RUB",
+  "RWF",
+  "SAR",
+  "SBD",
+  "SCR",
+  "SDG",
+  "SEK",
+  "SGD",
+  "SHP",
+  "SLE",
+  "SLL",
+  "SOS",
+  "SRD",
+  "SSP",
+  "STN",
+  "SYP",
+  "SZL",
+  "THB",
+  "TJS",
+  "TMT",
+  "TND",
+  "TOP",
+  "TRY",
+  "TTD",
+  "TVD",
+  "TWD",
+  "TZS",
+  "UAH",
+  "UGX",
+  "USD",
+  "USN",
+  "UYI",
+  "UYU",
+  "UYW",
+  "UZS",
+  "VED",
+  "VES",
+  "VND",
+  "VUV",
+  "WST",
+  "XAF",
+  "XAG",
+  "XAU",
+  "XBA",
+  "XBB",
+  "XBC",
+  "XBD",
+  "XCD",
+  "XDR",
+  "XOF",
+  "XPD",
+  "XPF",
+  "XPT",
+  "XSU",
+  "XTS",
+  "XUA",
+  "XXX",
+  "YER",
+  "ZAR",
+  "ZMW",
+  "ZWL"
+]);
+
+// core/src/schemas/models/inventory.model.ts
+import { z as z8 } from "zod";
+var InventorySchema = BaseModelSchema.extend({
+  quantity: z8.number().default(0)
+});
+
+// core/src/schemas/models/price.model.ts
+import { z as z9 } from "zod";
+var MonetaryAmountSchema = z9.looseInterface({
+  cents: z9.number().default(0).describe("The monetary amount in cent-precision."),
+  currency: CurrencySchema.default("XXX").describe("The currency associated with the amount, as a ISO 4217 standardized code.")
+});
+var PriceSchema = BaseModelSchema.extend({
+  identifier: PriceIdentifierSchema.default(() => PriceIdentifierSchema.parse({})),
+  value: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({}))
+});
+
+// core/src/schemas/models/product.model.ts
+import { z as z10 } from "zod";
+var SKUSchema = z10.looseInterface({
+  identifier: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({}))
+});
+var ProductAttributeSchema = z10.looseInterface({
+  id: z10.string(),
+  name: z10.string(),
+  value: z10.string()
+});
+var ProductSchema = BaseModelSchema.extend({
+  identifier: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
+  name: z10.string().default(""),
+  slug: z10.string().default(""),
+  description: z10.string().default(""),
+  image: z10.string().url().default("https://placehold.co/400"),
+  images: z10.string().url().array().default(() => []),
+  attributes: z10.array(ProductAttributeSchema).default(() => []),
+  skus: z10.array(SKUSchema).default(() => [])
+});
+
+// core/src/schemas/models/search.model.ts
+import { z as z11 } from "zod";
+var SearchResultProductSchema = z11.looseInterface({
+  identifier: ProductIdentifierSchema.default(ProductIdentifierSchema.parse({})),
+  name: z11.string().default(""),
+  image: z11.string().url().default("https://placehold.co/400"),
+  slug: z11.string().default("")
+});
+var SearchResultFacetValueSchema = z11.looseInterface({
+  identifier: FacetValueIdentifierSchema.default(() => FacetValueIdentifierSchema.parse({})),
+  name: z11.string().default(""),
+  count: z11.number().default(0),
+  active: z11.boolean().default(false)
+});
+var SearchResultFacetSchema = z11.looseInterface({
+  identifier: FacetIdentifierSchema.default(() => FacetIdentifierSchema.parse({})),
+  name: z11.string().default(""),
+  values: z11.array(SearchResultFacetValueSchema).default(() => [])
+});
+var SearchResultSchema = BaseModelSchema.extend({
+  identifier: SearchIdentifierSchema.default(() => SearchIdentifierSchema.parse({})),
+  products: z11.array(SearchResultProductSchema).default(() => []),
+  pages: z11.number().default(0),
+  facets: z11.array(SearchResultFacetSchema).default(() => [])
+});
+
+// core/src/schemas/mutations/base.mutation.ts
+import { z as z12 } from "zod";
+var BaseMutationSchema = z12.looseInterface({
+  mutation: z12.ZodLiteral
+});
+
+// core/src/schemas/mutations/cart.mutation.ts
+import { z as z13 } from "zod";
+var CartMutationItemAddSchema = BaseMutationSchema.extend({
+  mutation: z13.literal("add"),
+  cart: CartIdentifierSchema.required(),
+  product: ProductIdentifierSchema.required(),
+  quantity: z13.number()
+});
+var CartMutationItemRemoveSchema = BaseMutationSchema.extend({
+  mutation: z13.literal("remove"),
+  cart: CartIdentifierSchema.required(),
+  item: CartItemIdentifierSchema.required()
+});
+var CartMutationItemQuantityChangeSchema = BaseMutationSchema.extend({
+  mutation: z13.literal("adjustQuantity"),
+  cart: CartIdentifierSchema.required(),
+  item: CartItemIdentifierSchema.required(),
+  quantity: z13.number()
+});
+var CartMutationSchema = z13.union([CartMutationItemAddSchema, CartMutationItemRemoveSchema, CartMutationItemQuantityChangeSchema]);
+
+// core/src/schemas/mutations/identity.mutation.ts
+import { z as z14 } from "zod";
+var IdentityMutationLoginSchema = BaseMutationSchema.extend({
+  mutation: z14.literal("login"),
+  username: z14.string(),
+  password: z14.string()
+});
+var IdentityMutationLogoutSchema = BaseMutationSchema.extend({
+  mutation: z14.literal("logout")
+});
+var IdentityMutationSchema = z14.union([IdentityMutationLoginSchema, IdentityMutationLogoutSchema]);
+
+// core/src/schemas/mutations/inventory.mutation.ts
+import { z as z15 } from "zod";
+var InventoryMutationSchema = z15.union([]);
+
+// core/src/schemas/mutations/price.mutation.ts
+import { z as z16 } from "zod";
+var PriceMutationSchema = z16.union([]);
+
+// core/src/schemas/mutations/product.mutation.ts
+import { z as z17 } from "zod";
+var ProductMutationSchema = z17.union([]);
+
+// core/src/schemas/mutations/search.mutation.ts
+import { z as z18 } from "zod";
+var SearchMutationSchema = z18.union([]);
+
+// core/src/schemas/queries/base.query.ts
+import { z as z19 } from "zod";
+var BaseQuerySchema = z19.looseInterface({
+  query: z19.ZodLiteral
+});
+
+// core/src/schemas/queries/cart.query.ts
+import { z as z20 } from "zod";
+var CartQueryByIdSchema = BaseQuerySchema.extend({
+  query: z20.literal("id"),
+  cart: CartIdentifierSchema.required()
+});
+var CartQuerySchema = z20.union([CartQueryByIdSchema]);
+
+// core/src/schemas/queries/identity.query.ts
+import { z as z21 } from "zod";
+var IdentityQuerySelfSchema = BaseQuerySchema.extend({
+  query: z21.literal("self")
+});
+var IdentityQuerySchema = z21.union([IdentityQuerySelfSchema]);
+
+// core/src/schemas/queries/inventory.query.ts
+import { z as z22 } from "zod";
+var InventoryQuerySchema = BaseQuerySchema.extend({
+  query: z22.literal("sku"),
+  sku: z22.string()
+});
+
+// core/src/schemas/queries/price.query.ts
+import { z as z23 } from "zod";
+var PriceQueryBySkuSchema = BaseQuerySchema.extend({
+  query: z23.literal("sku"),
+  sku: SKUIdentifierSchema.required()
+});
+var PriceQuerySchema = z23.union([PriceQueryBySkuSchema]);
+
+// core/src/schemas/queries/product.query.ts
+import { z as z24 } from "zod";
+var ProductQueryBySlugSchema = BaseQuerySchema.extend({
+  query: z24.literal("slug"),
+  slug: z24.string()
+});
+var ProductQueryByIdSchema = BaseQuerySchema.extend({
+  query: z24.literal("id"),
+  id: z24.string()
+});
+var ProductQuerySchema = z24.union([ProductQueryBySlugSchema, ProductQueryByIdSchema]);
+
+// core/src/schemas/queries/search.query.ts
+import { z as z25 } from "zod";
+var SearchQueryByTermSchema = BaseQuerySchema.extend({
+  query: z25.literal("term"),
+  search: SearchIdentifierSchema.required()
+});
+var SearchQuerySchema = z25.union([SearchQueryByTermSchema]);
+
+// providers/fake/src/providers/product.provider.ts
+import { base, en, Faker } from "@faker-js/faker";
+var FakeProductProvider = class extends ProductProvider {
+  constructor(config, schema, querySchema, mutationSchema) {
+    super(schema, querySchema, mutationSchema);
+    this.config = config;
+  }
+  async fetch(queries, session) {
+    const results = new Array();
+    for (const query of queries) {
+      const generator = new Faker({
+        seed: 42,
+        locale: [en, base]
+      });
+      const key = query.id || generator.commerce.isbn();
+      const slug = query.slug || generator.lorem.slug();
+      const product = {
+        identifier: {
+          key
+        },
+        name: generator.commerce.productName(),
+        slug,
+        attributes: [],
+        description: generator.commerce.productDescription(),
+        image: generator.image.urlPicsumPhotos({
+          width: 600,
+          height: 600
+        }),
+        images: [],
+        meta: {
+          cache: {
+            hit: false,
+            key
+          },
+          placeholder: false
+        },
+        skus: []
+      };
+      results.push(product);
+    }
+    return results;
+  }
+  process(mutation, session) {
+    throw new Error("Method not implemented.");
+  }
+};
+
+// providers/fake/src/providers/search.provider.ts
+import { Faker as Faker2, en as en2, base as base2 } from "@faker-js/faker";
+
+// providers/fake/src/utilities/jitter.ts
+async function jitter(duration, deviation) {
+  const j = gaussianRandom(duration, deviation);
+  return new Promise((resolve) => setTimeout(resolve, j));
+}
+function gaussianRandom(mean, deviation) {
+  const u = 1 - Math.random();
+  const v = Math.random();
+  const z27 = Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+  return z27 * deviation + mean;
+}
+
+// providers/fake/src/providers/search.provider.ts
+var FakeSearchProvider = class extends SearchProvider {
+  constructor(config, schema, querySchema, mutationSchema) {
+    super(schema, querySchema, mutationSchema);
+    this.config = config;
+  }
+  async fetch(queries, session) {
+    const results = [];
+    for (const query of queries) {
+      const result = await this.get(query.search);
+      results.push(result);
+    }
+    return results;
+  }
+  process(mutations, session) {
+    throw new Error("Method not implemented.");
+  }
+  async get(identifier) {
+    await jitter(this.config.jitter.mean, this.config.jitter.deviation);
+    return this.parse({}, identifier);
+  }
+  parse(data, query) {
+    const querySpecificity = 20 - query.term.length - query.page - query.facets.length;
+    const totalProducts = 10 * querySpecificity;
+    const totalPages = Math.ceil(totalProducts / query.pageSize);
+    const productsOnPage = Math.min(totalProducts, query.pageSize);
+    const productGenerator = new Faker2({
+      seed: querySpecificity,
+      locale: [en2, base2]
+    });
+    const facetGenerator = new Faker2({
+      seed: 100,
+      locale: [en2, base2]
+    });
+    const products = new Array();
+    const facets = new Array();
+    for (let i = 0; i < productsOnPage; i++) {
+      products.push({
+        identifier: {
+          key: productGenerator.commerce.isbn()
+        },
+        image: productGenerator.image.urlPicsumPhotos({
+          height: 300,
+          width: 300,
+          grayscale: true,
+          blur: 8
+        }),
+        name: productGenerator.commerce.productName(),
+        slug: productGenerator.lorem.slug()
+      });
+    }
+    const facetBase = ["color", "size"];
+    for (const base3 of facetBase) {
+      const facet = {
+        identifier: {
+          key: base3
+        },
+        name: base3,
+        values: []
+      };
+      for (let i = 0; i < 10; i++) {
+        const valueKey = i.toString();
+        const isActive = query.facets.find(
+          (x) => x.facet.key === facet.identifier.key && x.key === valueKey
+        ) !== void 0;
+        facet.values.push({
+          active: isActive,
+          count: facetGenerator.number.int({ min: 1, max: 50 }),
+          identifier: {
+            facet: {
+              key: facet.identifier.key
+            },
+            key: valueKey
+          },
+          name: facetGenerator.color.human()
+        });
+      }
+      facets.push(facet);
+    }
+    const result = {
+      pages: totalPages,
+      identifier: {
+        term: query.term,
+        page: query.page,
+        facets: query.facets,
+        pageSize: query.pageSize
+      },
+      facets,
+      products,
+      meta: {
+        cache: {
+          hit: false,
+          key: ""
+        },
+        placeholder: false
+      }
+    };
+    return this.schema.parse(result);
+  }
+};
+
+// providers/fake/src/providers/identity.provider.ts
+import { faker } from "@faker-js/faker";
+var FakeIdentityProvider = class extends IdentityProvider {
+  constructor(config, schema, querySchema, mutationSchema) {
+    super(schema, querySchema, mutationSchema);
+    this.config = config;
+  }
+  async fetch(queries, session) {
+    const results = [];
+    for (const query of queries) {
+      const result = await this.get(session);
+      results.push(result);
+    }
+    return results;
+  }
+  async process(mutations, session) {
+    let result = this.newModel();
+    for (const mutation of mutations) {
+      switch (mutation.mutation) {
+        case "login":
+          result = await this.login(mutation, session);
+          break;
+        case "logout":
+          result = await this.logout(session);
+          break;
+      }
+    }
+    return result;
+  }
+  async login(payload, session) {
+    const base3 = this.newModel();
+    base3.id = faker.string.uuid();
+    base3.token = faker.string.uuid();
+    base3.issued = faker.date.recent();
+    base3.issued = faker.date.soon();
+    base3.type = "Registered";
+    return base3;
+  }
+  async get(session) {
+    const base3 = this.schema.parse(session.identity);
+    return base3;
+  }
+  async logout(session) {
+    const base3 = this.newModel();
+    session.identity = base3;
+    return base3;
+  }
+};
+
+// providers/fake/src/core/initialize.ts
+function withFakeCapabilities(configuration, capabilities) {
+  const client = {};
+  if (capabilities.product) {
+    client.product = new FakeProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema);
+  }
+  if (capabilities.search) {
+    client.search = new FakeSearchProvider(configuration, SearchResultSchema, SearchQuerySchema, SearchMutationSchema);
+  }
+  if (capabilities.identity) {
+    client.identity = new FakeIdentityProvider(configuration, IdentitySchema, IdentityQuerySchema, IdentityMutationSchema);
+  }
+  return client;
+}
+
+// providers/fake/src/schema/capabilities.schema.ts
+var FakeCapabilitiesSchema = CapabilitiesSchema.pick({
+  product: true,
+  search: true,
+  identity: true
+}).partial();
+
+// providers/fake/src/schema/configuration.schema.ts
+import { z as z26 } from "zod";
+var FakeConfigurationSchema = z26.looseInterface({
+  jitter: z26.looseInterface({
+    mean: z26.number().min(0).max(1e4),
+    deviation: z26.number().min(0).max(5e3)
+  }).default({
+    mean: 0,
+    deviation: 0
+  })
+});
+export {
+  FakeCapabilitiesSchema,
+  FakeConfigurationSchema,
+  FakeIdentityProvider,
+  FakeProductProvider,
+  FakeSearchProvider,
+  withFakeCapabilities
+};

package/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@reactionary/provider-fake",
+  "version": "0.0.27",
+  "dependencies": {
+    "@reactionary/core": "0.0.27",
+    "zod": "4.0.0-beta.20250430T185432",
+    "@faker-js/faker": "^9.8.0"
+  }
+}

package/src/core/initialize.d.ts

@@ -0,0 +1,4 @@
+import { Client } from "@reactionary/core";
+import { FakeConfiguration } from "../schema/configuration.schema";
+import { FakeCapabilities } from "../schema/capabilities.schema";
+export declare function withFakeCapabilities(configuration: FakeConfiguration, capabilities: FakeCapabilities): Partial<Client>;

package/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './core/initialize';
+export * from './providers/identity.provider';
+export * from './providers/product.provider';
+export * from './providers/search.provider';
+export * from './schema/capabilities.schema';
+export * from './schema/configuration.schema';

package/src/providers/identity.provider.d.ts

@@ -0,0 +1,12 @@
+import { Identity, IdentityMutation, IdentityMutationLogin, IdentityProvider, IdentityQuery, Session } from '@reactionary/core';
+import { FakeConfiguration } from '../schema/configuration.schema';
+import z from 'zod';
+export declare class FakeIdentityProvider<T extends Identity = Identity, Q extends IdentityQuery = IdentityQuery, M extends IdentityMutation = IdentityMutation> extends IdentityProvider<T, Q, M> {
+    protected config: FakeConfiguration;
+    constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>);
+    protected fetch(queries: Q[], session: Session): Promise<T[]>;
+    protected process(mutations: M[], session: Session): Promise<T>;
+    protected login(payload: IdentityMutationLogin, session: Session): Promise<T>;
+    protected get(session: Session): Promise<T>;
+    protected logout(session: Session): Promise<T>;
+}

package/src/providers/product.provider.d.ts

@@ -0,0 +1,9 @@
+import { BaseMutation, Product, ProductMutation, ProductProvider, ProductQuery, Session } from '@reactionary/core';
+import z from 'zod';
+import { FakeConfiguration } from '../schema/configuration.schema';
+export declare class FakeProductProvider<T extends Product = Product, Q extends ProductQuery = ProductQuery, M extends ProductMutation = ProductMutation> extends ProductProvider<T, Q, M> {
+    protected config: FakeConfiguration;
+    constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>);
+    protected fetch(queries: Q[], session: Session): Promise<T[]>;
+    protected process(mutation: BaseMutation[], session: Session): Promise<T>;
+}

package/src/providers/search.provider.d.ts

@@ -0,0 +1,11 @@
+import { SearchIdentifier, SearchMutation, SearchProvider, SearchQuery, SearchResult, Session } from '@reactionary/core';
+import z from 'zod';
+import { FakeConfiguration } from '../schema/configuration.schema';
+export declare class FakeSearchProvider<T extends SearchResult = SearchResult, Q extends SearchQuery = SearchQuery, M extends SearchMutation = SearchMutation> extends SearchProvider<T, Q, M> {
+    protected config: FakeConfiguration;
+    constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>);
+    protected fetch(queries: Q[], session: Session): Promise<T[]>;
+    protected process(mutations: M[], session: Session): Promise<T>;
+    get(identifier: SearchIdentifier): Promise<T>;
+    parse(data: unknown, query: SearchIdentifier): T;
+}

package/src/schema/capabilities.schema.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const FakeCapabilitiesSchema: z.ZodInterface<{
+    identity: z.ZodOptional<z.ZodBoolean>;
+    search: z.ZodOptional<z.ZodBoolean>;
+    product: z.ZodOptional<z.ZodBoolean>;
+}, {
+    optional: "identity" | "search" | "product";
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export type FakeCapabilities = z.infer<typeof FakeCapabilitiesSchema>;

package/src/schema/configuration.schema.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const FakeConfigurationSchema: z.ZodInterface<{
+    jitter: z.ZodDefault<z.ZodInterface<{
+        mean: z.ZodNumber;
+        deviation: z.ZodNumber;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export type FakeConfiguration = z.infer<typeof FakeConfigurationSchema>;

package/src/utilities/jitter.d.ts

@@ -0,0 +1 @@
+export declare function jitter(duration: number, deviation: number): Promise<unknown>;