@reactionary/provider-algolia 0.0.35 → 0.0.37

package/core/initialize.js

@@ -0,0 +1,19 @@
+import { ProductSchema } from "@reactionary/core";
+import { AlgoliaProductProvider } from "../providers/product.provider";
+import { AlgoliaSearchProvider } from "../providers/search.provider";
+import { AlgoliaSearchResultSchema } from "../schema/search.schema";
+function withAlgoliaCapabilities(configuration, capabilities) {
+  return (cache) => {
+    const client = {};
+    if (capabilities.product) {
+      client.product = new AlgoliaProductProvider(configuration, ProductSchema, cache);
+    }
+    if (capabilities.search) {
+      client.search = new AlgoliaSearchProvider(configuration, AlgoliaSearchResultSchema, cache);
+    }
+    return client;
+  };
+}
+export {
+  withAlgoliaCapabilities
+};

package/index.js

@@ -1,623 +1,5 @@
-// core/src/cache/redis-cache.ts
-import { Redis } from "@upstash/redis";
-
-// core/src/decorators/trpc.decorators.ts
-import "reflect-metadata";
-var TRPC_QUERY_METADATA_KEY = Symbol("trpc:query");
-var TRPC_MUTATION_METADATA_KEY = Symbol("trpc:mutation");
-
-// core/src/providers/base.provider.ts
-var BaseProvider = class {
-  constructor(schema, cache) {
-    this.schema = schema;
-    this.cache = cache;
-  }
-  /**
-   * 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({});
-  }
-  /**
-   * Handler for parsing a response from a remote provider and converting it
-   * into the typed domain model.
-   */
-  parseSingle(_body) {
-    const model = this.newModel();
-    return this.assert(model);
-  }
-};
-
-// 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({});
-
-// core/src/schemas/mutations/cart.mutation.ts
-import { z as z13 } from "zod";
-var CartMutationItemAddSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required(),
-  product: ProductIdentifierSchema.required(),
-  quantity: z13.number()
-});
-var CartMutationItemRemoveSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required(),
-  item: CartItemIdentifierSchema.required()
-});
-var CartMutationItemQuantityChangeSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required(),
-  item: CartItemIdentifierSchema.required(),
-  quantity: z13.number()
-});
-
-// core/src/schemas/mutations/identity.mutation.ts
-import { z as z14 } from "zod";
-var IdentityMutationLoginSchema = BaseMutationSchema.extend({
-  username: z14.string(),
-  password: z14.string()
-});
-var IdentityMutationLogoutSchema = BaseMutationSchema.extend({});
-
-// 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({});
-
-// core/src/schemas/queries/cart.query.ts
-import { z as z20 } from "zod";
-var CartQueryByIdSchema = BaseQuerySchema.extend({
-  cart: CartIdentifierSchema.required()
-});
-var CartQuerySchema = z20.union([CartQueryByIdSchema]);
-
-// core/src/schemas/queries/identity.query.ts
-var IdentityQuerySelfSchema = BaseQuerySchema.extend({});
-
-// core/src/schemas/queries/inventory.query.ts
-import { z as z21 } from "zod";
-var InventoryQuerySchema = BaseQuerySchema.extend({
-  sku: z21.string()
-});
-
-// core/src/schemas/queries/price.query.ts
-var PriceQueryBySkuSchema = BaseQuerySchema.extend({
-  sku: SKUIdentifierSchema.required()
-});
-
-// core/src/schemas/queries/product.query.ts
-import { z as z22 } from "zod";
-var ProductQueryBySlugSchema = BaseQuerySchema.extend({
-  slug: z22.string()
-});
-var ProductQueryByIdSchema = BaseQuerySchema.extend({
-  id: z22.string()
-});
-
-// core/src/schemas/queries/search.query.ts
-var SearchQueryByTermSchema = BaseQuerySchema.extend({
-  search: SearchIdentifierSchema.required()
-});
-
-// providers/algolia/src/providers/product.provider.ts
-var AlgoliaProductProvider = class extends ProductProvider {
-  constructor(config, schema, cache) {
-    super(schema, cache);
-    this.config = config;
-  }
-  async getById(payload, _session) {
-    const result = this.newModel();
-    result.identifier = { key: payload.id };
-    result.name = `Algolia Product ${payload.id}`;
-    result.slug = payload.id;
-    result.description = "Product from Algolia";
-    result.meta = {
-      cache: { hit: false, key: payload.id },
-      placeholder: true
-    };
-    return this.assert(result);
-  }
-  async getBySlug(payload, _session) {
-    const result = this.newModel();
-    result.identifier = { key: payload.slug };
-    result.name = `Algolia Product ${payload.slug}`;
-    result.slug = payload.slug;
-    result.description = "Product from Algolia";
-    result.meta = {
-      cache: { hit: false, key: payload.slug },
-      placeholder: true
-    };
-    return this.assert(result);
-  }
-};
-
-// providers/algolia/src/providers/search.provider.ts
-import { algoliasearch } from "algoliasearch";
-var AlgoliaSearchProvider = class extends SearchProvider {
-  constructor(config, schema, cache) {
-    super(schema, cache);
-    this.config = config;
-  }
-  async queryByTerm(payload, _session) {
-    const client = algoliasearch(this.config.appId, this.config.apiKey);
-    const remote = await client.search({
-      requests: [
-        {
-          indexName: this.config.indexName,
-          query: payload.search.term,
-          page: payload.search.page,
-          hitsPerPage: payload.search.pageSize,
-          facets: ["*"],
-          analytics: true,
-          clickAnalytics: true,
-          facetFilters: payload.search.facets.map(
-            (x) => `${encodeURIComponent(x.facet.key)}:${x.key}`
-          )
-        }
-      ]
-    });
-    return this.parseSearchResult(remote, payload);
-  }
-  parseSearchResult(remote, payload) {
-    const result = this.newModel();
-    const remoteData = remote;
-    const remoteProducts = remoteData.results[0];
-    for (const id in remoteProducts.facets) {
-      const f = remoteProducts.facets[id];
-      const facet = {
-        identifier: { key: id },
-        name: id,
-        values: []
-      };
-      for (const vid in f) {
-        const fv = f[vid];
-        const isActive = payload.search.facets.find(
-          (x) => x.facet.key === id && x.key === vid
-        );
-        facet.values.push({
-          identifier: { key: vid, facet: { key: id } },
-          count: fv,
-          name: vid,
-          active: !!isActive
-        });
-      }
-      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 = {
-      ...payload.search,
-      index: remoteProducts.index,
-      key: remoteProducts.queryID
-    };
-    result.pages = remoteProducts.nbPages;
-    result.meta = {
-      cache: { hit: false, key: payload.search.term },
-      placeholder: false
-    };
-    return this.assert(result);
-  }
-};
-
-// providers/algolia/src/schema/search.schema.ts
-import { z as z23 } from "zod";
-var AlgoliaSearchIdentifierSchema = SearchIdentifierSchema.extend({
-  key: z23.string().default(""),
-  index: z23.string().default("")
-});
-var AlgoliaSearchResultSchema = SearchResultSchema.extend({
-  identifier: AlgoliaSearchIdentifierSchema.default(() => AlgoliaSearchIdentifierSchema.parse({}))
-});
-
-// providers/algolia/src/core/initialize.ts
-function withAlgoliaCapabilities(configuration, capabilities) {
-  return (cache) => {
-    const client = {};
-    if (capabilities.product) {
-      client.product = new AlgoliaProductProvider(configuration, ProductSchema, cache);
-    }
-    if (capabilities.search) {
-      client.search = new AlgoliaSearchProvider(configuration, AlgoliaSearchResultSchema, cache);
-    }
-    return client;
-  };
-}
-
-// providers/algolia/src/schema/configuration.schema.ts
-import { z as z24 } from "zod";
-var AlgoliaConfigurationSchema = z24.looseInterface({
-  appId: z24.string(),
-  apiKey: z24.string(),
-  indexName: z24.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
-};
+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/package.json

@@ -1,8 +1,10 @@
 {
   "name": "@reactionary/provider-algolia",
-  "version": "0.0.35",
+  "version": "0.0.37",
+  "main": "index.js",
+  "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.0.35",
+    "@reactionary/core": "0.0.37",
     "algoliasearch": "^5.23.4",
     "zod": "4.0.0-beta.20250430T185432"
   }

package/providers/product.provider.js

@@ -0,0 +1,36 @@
+import {
+  ProductProvider
+} from "@reactionary/core";
+class AlgoliaProductProvider extends ProductProvider {
+  constructor(config, schema, cache) {
+    super(schema, cache);
+    this.config = config;
+  }
+  async getById(payload, _session) {
+    const result = this.newModel();
+    result.identifier = { key: payload.id };
+    result.name = `Algolia Product ${payload.id}`;
+    result.slug = payload.id;
+    result.description = "Product from Algolia";
+    result.meta = {
+      cache: { hit: false, key: payload.id },
+      placeholder: true
+    };
+    return this.assert(result);
+  }
+  async getBySlug(payload, _session) {
+    const result = this.newModel();
+    result.identifier = { key: payload.slug };
+    result.name = `Algolia Product ${payload.slug}`;
+    result.slug = payload.slug;
+    result.description = "Product from Algolia";
+    result.meta = {
+      cache: { hit: false, key: payload.slug },
+      placeholder: true
+    };
+    return this.assert(result);
+  }
+}
+export {
+  AlgoliaProductProvider
+};

package/providers/search.provider.js

@@ -0,0 +1,78 @@
+import {
+  SearchProvider
+} from "@reactionary/core";
+import { algoliasearch } from "algoliasearch";
+class AlgoliaSearchProvider extends SearchProvider {
+  constructor(config, schema, cache) {
+    super(schema, cache);
+    this.config = config;
+  }
+  async queryByTerm(payload, _session) {
+    const client = algoliasearch(this.config.appId, this.config.apiKey);
+    const remote = await client.search({
+      requests: [
+        {
+          indexName: this.config.indexName,
+          query: payload.search.term,
+          page: payload.search.page,
+          hitsPerPage: payload.search.pageSize,
+          facets: ["*"],
+          analytics: true,
+          clickAnalytics: true,
+          facetFilters: payload.search.facets.map(
+            (x) => `${encodeURIComponent(x.facet.key)}:${x.key}`
+          )
+        }
+      ]
+    });
+    return this.parseSearchResult(remote, payload);
+  }
+  parseSearchResult(remote, payload) {
+    const result = this.newModel();
+    const remoteData = remote;
+    const remoteProducts = remoteData.results[0];
+    for (const id in remoteProducts.facets) {
+      const f = remoteProducts.facets[id];
+      const facet = {
+        identifier: { key: id },
+        name: id,
+        values: []
+      };
+      for (const vid in f) {
+        const fv = f[vid];
+        const isActive = payload.search.facets.find(
+          (x) => x.facet.key === id && x.key === vid
+        );
+        facet.values.push({
+          identifier: { key: vid, facet: { key: id } },
+          count: fv,
+          name: vid,
+          active: !!isActive
+        });
+      }
+      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 = {
+      ...payload.search,
+      index: remoteProducts.index,
+      key: remoteProducts.queryID
+    };
+    result.pages = remoteProducts.nbPages;
+    result.meta = {
+      cache: { hit: false, key: payload.search.term },
+      placeholder: false
+    };
+    return this.assert(result);
+  }
+}
+export {
+  AlgoliaSearchProvider
+};

package/schema/capabilities.schema.js

@@ -0,0 +1,9 @@
+import { CapabilitiesSchema } from "@reactionary/core";
+const AlgoliaCapabilitiesSchema = CapabilitiesSchema.pick({
+  product: true,
+  search: true,
+  analytics: true
+}).partial();
+export {
+  AlgoliaCapabilitiesSchema
+};

package/schema/configuration.schema.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+const AlgoliaConfigurationSchema = z.looseInterface({
+  appId: z.string(),
+  apiKey: z.string(),
+  indexName: z.string()
+});
+export {
+  AlgoliaConfigurationSchema
+};

package/schema/search.schema.js

@@ -0,0 +1,13 @@
+import { SearchIdentifierSchema, SearchResultSchema } from "@reactionary/core";
+import { z } from "zod";
+const AlgoliaSearchIdentifierSchema = SearchIdentifierSchema.extend({
+  key: z.string().default(""),
+  index: z.string().default("")
+});
+const AlgoliaSearchResultSchema = SearchResultSchema.extend({
+  identifier: AlgoliaSearchIdentifierSchema.default(() => AlgoliaSearchIdentifierSchema.parse({}))
+});
+export {
+  AlgoliaSearchIdentifierSchema,
+  AlgoliaSearchResultSchema
+};