@reactionary/provider-algolia 0.0.27

package/README.md

@@ -0,0 +1,11 @@
+# provider-algolia
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build provider-algolia` to build the library.
+
+## Running unit tests
+
+Run `nx test provider-algolia` to execute the unit tests via [Jest](https://jestjs.io).

package/index.js

@@ -0,0 +1,649 @@
+// 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/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/algolia/src/providers/product.provider.ts
+var AlgoliaProductProvider = class extends ProductProvider {
+  constructor(config, schema, querySchema, mutationSchema) {
+    super(schema, querySchema, mutationSchema);
+    this.config = config;
+  }
+  async fetch(queries, session) {
+    return [];
+  }
+  process(mutation, session) {
+    throw new Error("Method not implemented.");
+  }
+};
+
+// providers/algolia/src/providers/search.provider.ts
+import { algoliasearch } from "algoliasearch";
+var AlgoliaSearchProvider = 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) {
+    const client = algoliasearch(this.config.appId, this.config.apiKey);
+    const remote = await client.search({
+      requests: [
+        {
+          indexName: this.config.indexName,
+          query: identifier.term,
+          page: identifier.page,
+          hitsPerPage: identifier.pageSize,
+          facets: ["*"],
+          analytics: true,
+          clickAnalytics: true,
+          facetFilters: identifier.facets.map(
+            (x) => `${encodeURIComponent(x.facet.key)}:${x.key}`
+          )
+        }
+      ]
+    });
+    const parsed = this.parse(remote, identifier);
+    return parsed;
+  }
+  parse(remote, query) {
+    const result = this.newModel();
+    const remoteProducts = remote.results[0];
+    for (const id in remoteProducts.facets) {
+      const f = remoteProducts.facets[id];
+      const facet = SearchResultFacetSchema.parse({});
+      facet.identifier.key = id;
+      facet.name = id;
+      for (const vid in f) {
+        const fv = f[vid];
+        const facetValue = SearchResultFacetValueSchema.parse({});
+        facetValue.count = fv;
+        facetValue.name = vid;
+        facetValue.identifier.key = vid;
+        facetValue.identifier.facet = facet.identifier;
+        if (query.facets.find(
+          (x) => x.facet.key == facetValue.identifier.facet.key && x.key == facetValue.identifier.key
+        )) {
+          facetValue.active = true;
+        }
+        facet.values.push(facetValue);
+      }
+      result.facets.push(facet);
+    }
+    for (const p of remoteProducts.hits) {
+      result.products.push({
+        identifier: {
+          key: p.objectID
+        },
+        slug: p.slug,
+        name: p.name,
+        image: p.image
+      });
+    }
+    result.identifier = {
+      ...query,
+      index: remoteProducts.index,
+      key: remoteProducts.queryID
+    };
+    result.pages = remoteProducts.nbPages;
+    return result;
+  }
+};
+
+// providers/algolia/src/schema/search.schema.ts
+import { z as z26 } from "zod";
+var AlgoliaSearchIdentifierSchema = SearchIdentifierSchema.extend({
+  key: z26.string().default(""),
+  index: z26.string().default("")
+});
+var AlgoliaSearchResultSchema = SearchResultSchema.extend({
+  identifier: AlgoliaSearchIdentifierSchema.default(() => AlgoliaSearchIdentifierSchema.parse({}))
+});
+
+// providers/algolia/src/core/initialize.ts
+function withAlgoliaCapabilities(configuration, capabilities) {
+  const client = {};
+  if (capabilities.product) {
+    client.product = new AlgoliaProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema);
+  }
+  if (capabilities.search) {
+    client.search = new AlgoliaSearchProvider(configuration, AlgoliaSearchResultSchema, SearchQuerySchema, SearchMutationSchema);
+  }
+  return client;
+}
+
+// providers/algolia/src/schema/configuration.schema.ts
+import { z as z27 } from "zod";
+var AlgoliaConfigurationSchema = z27.looseInterface({
+  appId: z27.string(),
+  apiKey: z27.string(),
+  indexName: z27.string()
+});
+
+// providers/algolia/src/schema/capabilities.schema.ts
+var AlgoliaCapabilitiesSchema = CapabilitiesSchema.pick({
+  product: true,
+  search: true,
+  analytics: true
+}).partial();
+export {
+  AlgoliaCapabilitiesSchema,
+  AlgoliaConfigurationSchema,
+  AlgoliaProductProvider,
+  AlgoliaSearchProvider,
+  withAlgoliaCapabilities
+};

package/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@reactionary/provider-algolia",
+  "version": "0.0.27",
+  "dependencies": {
+    "@reactionary/core": "0.0.27",
+    "algoliasearch": "^5.23.4",
+    "zod": "4.0.0-beta.20250430T185432"
+  }
+}

package/src/core/initialize.d.ts

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

package/src/index.d.ts

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

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 { AlgoliaConfiguration } from '../schema/configuration.schema';
+export declare class AlgoliaProductProvider<T extends Product = Product, Q extends ProductQuery = ProductQuery, M extends ProductMutation = ProductMutation> extends ProductProvider<T, Q, M> {
+    protected config: AlgoliaConfiguration;
+    constructor(config: AlgoliaConfiguration, 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 { AlgoliaConfiguration } from '../schema/configuration.schema';
+export declare class AlgoliaSearchProvider<T extends SearchResult = SearchResult, Q extends SearchQuery = SearchQuery, M extends SearchMutation = SearchMutation> extends SearchProvider<T, Q, M> {
+    protected config: AlgoliaConfiguration;
+    constructor(config: AlgoliaConfiguration, 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 get(identifier: SearchIdentifier): Promise<T>;
+    protected parse(remote: any, query: SearchIdentifier): T;
+}

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

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

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const AlgoliaConfigurationSchema: z.ZodInterface<{
+    appId: z.ZodString;
+    apiKey: z.ZodString;
+    indexName: z.ZodString;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export type AlgoliaConfiguration = z.infer<typeof AlgoliaConfigurationSchema>;

package/src/schema/search.schema.d.ts

@@ -0,0 +1,171 @@
+import { z } from 'zod';
+export declare const AlgoliaSearchIdentifierSchema: z.MergeInterfaces<z.ZodInterface<{
+    term: z.ZodDefault<z.ZodString>;
+    page: z.ZodDefault<z.ZodNumber>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    facets: z.ZodDefault<z.ZodArray<z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+        facet: z.ZodNonOptional<z.ZodDefault<z.ZodInterface<{
+            key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+        }, {
+            optional: never;
+            defaulted: never;
+            extra: Record<string, unknown>;
+        }>>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    key: z.ZodDefault<z.ZodString>;
+    index: z.ZodDefault<z.ZodString>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export declare const AlgoliaSearchResultSchema: z.MergeInterfaces<z.MergeInterfaces<z.ZodInterface<{
+    meta: z.ZodDefault<z.ZodInterface<{
+        cache: z.ZodDefault<z.ZodInterface<{
+            hit: z.ZodDefault<z.ZodBoolean>;
+            key: z.ZodDefault<z.ZodString>;
+        }, {
+            optional: never;
+            defaulted: never;
+            extra: Record<string, unknown>;
+        }>>;
+        placeholder: z.ZodDefault<z.ZodBoolean>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    identifier: z.ZodDefault<z.ZodInterface<{
+        term: z.ZodDefault<z.ZodString>;
+        page: z.ZodDefault<z.ZodNumber>;
+        pageSize: z.ZodDefault<z.ZodNumber>;
+        facets: z.ZodDefault<z.ZodArray<z.ZodInterface<{
+            key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+            facet: z.ZodNonOptional<z.ZodDefault<z.ZodInterface<{
+                key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+            }, {
+                optional: never;
+                defaulted: never;
+                extra: Record<string, unknown>;
+            }>>>;
+        }, {
+            optional: never;
+            defaulted: never;
+            extra: Record<string, unknown>;
+        }>>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+    products: z.ZodDefault<z.ZodArray<z.ZodInterface<{
+        identifier: z.ZodDefault<z.ZodInterface<{
+            key: z.ZodDefault<z.ZodString>;
+        }, {
+            optional: never;
+            defaulted: never;
+            extra: Record<string, unknown>;
+        }>>;
+        name: z.ZodDefault<z.ZodString>;
+        image: z.ZodDefault<z.ZodString>;
+        slug: z.ZodDefault<z.ZodString>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>>;
+    pages: z.ZodDefault<z.ZodNumber>;
+    facets: z.ZodDefault<z.ZodArray<z.ZodInterface<{
+        identifier: z.ZodDefault<z.ZodInterface<{
+            key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+        }, {
+            optional: never;
+            defaulted: never;
+            extra: Record<string, unknown>;
+        }>>;
+        name: z.ZodDefault<z.ZodString>;
+        values: z.ZodDefault<z.ZodArray<z.ZodInterface<{
+            identifier: z.ZodDefault<z.ZodInterface<{
+                facet: z.ZodDefault<z.ZodInterface<{
+                    key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+                }, {
+                    optional: never;
+                    defaulted: never;
+                    extra: Record<string, unknown>;
+                }>>;
+                key: z.ZodDefault<z.ZodString>;
+            }, {
+                optional: never;
+                defaulted: never;
+                extra: Record<string, unknown>;
+            }>>;
+            name: z.ZodDefault<z.ZodString>;
+            count: z.ZodDefault<z.ZodNumber>;
+            active: z.ZodDefault<z.ZodBoolean>;
+        }, {
+            optional: never;
+            defaulted: never;
+            extra: Record<string, unknown>;
+        }>>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>, z.ZodInterface<{
+    identifier: z.ZodDefault<z.MergeInterfaces<z.ZodInterface<{
+        term: z.ZodDefault<z.ZodString>;
+        page: z.ZodDefault<z.ZodNumber>;
+        pageSize: z.ZodDefault<z.ZodNumber>;
+        facets: z.ZodDefault<z.ZodArray<z.ZodInterface<{
+            key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+            facet: z.ZodNonOptional<z.ZodDefault<z.ZodInterface<{
+                key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+            }, {
+                optional: never;
+                defaulted: never;
+                extra: Record<string, unknown>;
+            }>>>;
+        }, {
+            optional: never;
+            defaulted: never;
+            extra: Record<string, unknown>;
+        }>>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>, z.ZodInterface<{
+        key: z.ZodDefault<z.ZodString>;
+        index: z.ZodDefault<z.ZodString>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: {};
+    }>>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export type AlgoliaSearchResult = z.infer<typeof AlgoliaSearchResultSchema>;
+export type AlgoliaSearchIdentifier = z.infer<typeof AlgoliaSearchIdentifierSchema>;