@decocms/apps-algolia 7.72.0 → 8.1.0-next.1

package/package.json

@@ -1,45 +1,31 @@
 {
   "name": "@decocms/apps-algolia",
-  "version": "7.72.0",
+  "version": "8.1.0-next.1",
   "type": "module",
-  "description": "Deco commerce app: Algolia search integration",
+  "description": "Thin client for the Algolia Search REST API",
   "repository": {
     "type": "git",
     "url": "https://github.com/decocms/blocks.git",
     "directory": "packages/apps-algolia"
   },
+  "files": [
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/__tests__"
+  ],
   "main": "./src/index.ts",
   "exports": {
-    ".": "./src/index.ts",
-    "./client": "./src/client.ts",
-    "./types": "./src/types.ts",
-    "./loaders/*": "./src/loaders/*.ts"
+    ".": "./src/index.ts"
   },
   "scripts": {
     "build": "tsc",
     "test": "vitest run --root ../.. packages/apps-algolia/",
-    "typecheck": "tsc --noEmit",
-    "lint:unused": "knip"
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@decocms/blocks": "7.72.0",
-    "@decocms/apps-commerce": "7.72.0"
-  },
-  "peerDependencies": {
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "algoliasearch": "^5"
-  },
-  "peerDependenciesMeta": {
-    "algoliasearch": {
-      "optional": true
-    }
+    "@decocms/blocks": "8.1.0-next.1"
   },
   "devDependencies": {
-    "@types/react": "^19.0.0",
-    "@types/react-dom": "^19.0.0",
-    "algoliasearch": "^5.53.0",
-    "knip": "^5.86.0",
     "typescript": "^5.9.0"
   },
   "publishConfig": {

package/src/index.ts

@@ -1,12 +1,86 @@
 /**
- * Algolia app entry point for @decocms/apps.
- * Re-exports client config + initializer + types.
+ * `@decocms/apps-algolia`: a thin client for the Algolia Search REST API.
+ * See /next/upstream-clients.
  *
- * For loaders, use sub-path imports:
- *   import client from "@decocms/apps/algolia/loaders/client"
- *
- * For the SDK SearchClient directly (no proxy hop on the server):
- *   import { getAlgoliaClient } from "@decocms/apps/algolia/client"
+ * It calls the REST API directly rather than through the `algoliasearch`
+ * SDK, so every request goes through `createInstrumentedFetch` (provider
+ * `algolia`) like every other client. No retries or circuit breaker, and no
+ * response cache: caching upstream data is the site's job.
  */
-export * from "./client";
-export type { AlgoliaConfig, Indices } from "./types";
+import { createInstrumentedFetch } from "@decocms/blocks/fetch";
+
+export interface AlgoliaClientConfig {
+  applicationId: string;
+  /** A search-only key is enough for search; never send an admin key to the browser. */
+  apiKey: string;
+}
+
+/** One query: the index plus search parameters as the REST API names them (`query`, `hitsPerPage`, `filters`, ...). */
+export interface AlgoliaSearchRequest {
+  indexName: string;
+  query?: string;
+  [param: string]: unknown;
+}
+
+export type AlgoliaHit<T> = T & { objectID: string; [field: string]: unknown };
+
+export interface AlgoliaSearchResponse<T = Record<string, unknown>> {
+  hits: AlgoliaHit<T>[];
+  nbHits: number;
+  page: number;
+  nbPages: number;
+  hitsPerPage: number;
+  processingTimeMS: number;
+  query: string;
+  params: string;
+  index?: string;
+  queryID?: string;
+  facets?: Record<string, Record<string, number>>;
+  [field: string]: unknown;
+}
+
+export class AlgoliaError extends Error {
+  constructor(
+    readonly operation: string,
+    readonly status: number,
+  ) {
+    super(`algolia ${operation} failed with HTTP ${status}`);
+  }
+}
+
+export function createAlgoliaClient(
+  config: AlgoliaClientConfig,
+  options: { fetch?: typeof globalThis.fetch } = {},
+) {
+  // The id becomes part of the host; reject anything that could redirect the API key elsewhere.
+  if (!/^[A-Za-z0-9]+$/.test(config.applicationId))
+    throw new Error("algolia: invalid applicationId");
+  const request = createInstrumentedFetch({ provider: "algolia", fetch: options.fetch });
+  const host = `https://${config.applicationId}-dsn.algolia.net`;
+
+  async function post<R>(operation: string, path: string, body: unknown): Promise<R> {
+    const response = await request(`${host}${path}`, {
+      operation,
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-algolia-application-id": config.applicationId,
+        "x-algolia-api-key": config.apiKey,
+      },
+      body: JSON.stringify(body),
+    });
+    if (!response.ok) throw new AlgoliaError(operation, response.status);
+    return (await response.json()) as R;
+  }
+
+  return {
+    /** Runs several queries, on one or more indices, in one request. */
+    search<T = Record<string, unknown>>(
+      requests: AlgoliaSearchRequest[],
+    ): Promise<{ results: AlgoliaSearchResponse<T>[] }> {
+      return post("search", "/1/indexes/*/queries", { requests });
+    },
+  };
+}
+
+export type AlgoliaClient = ReturnType<typeof createAlgoliaClient>;

package/src/README.md

@@ -1,89 +0,0 @@
-# Algolia app — initial scaffold
-
-This folder ports the Algolia integration from `deco-cx/apps/algolia`
-(Fresh/Deno) to `@decocms/apps/algolia` (TanStack Start/Node), following
-the same shape as `vtex/`, `magento/`, and `shopify/`.
-
-## Status
-
-**Initial scaffold** — covers the `configureAlgolia`/`getAlgoliaClient`
-surface plus the `loaders/client.ts` shim that matches the upstream
-`apps/algolia/loaders/client.ts` call site (`ctx.invoke.algolia.loaders.client({})`).
-Just enough for downstream sites with their own product loaders to wire
-Algolia and consume the SDK SearchClient directly.
-
-A real-world consumer (a production Algolia storefront) is migrating away
-from the legacy `ctx.invoke.algolia.loaders.client({})` proxy that
-existed in the Fresh runtime. The site keeps its own product loaders
-(custom storefront-specific transforms over the upstream toProduct) and only needs
-the SDK client from this package.
-
-## What's here
-
-- `client.ts` — `configureAlgolia({ applicationId, searchApiKey,
-  adminApiKey })` + `getAlgoliaConfig()` accessor + lazy
-  `getAlgoliaClient()` cached singleton. Mirrors `configureMagento` /
-  `configureVtex`.
-- `types.ts` — `AlgoliaConfig`, canonical `Indices` union.
-- `loaders/client.ts` — returns the configured `SearchClient` so legacy
-  call sites (`invoke.algolia.loaders.client({})`) keep working when
-  routed through the loader registry.
-- `index.ts` — re-export entry.
-
-## Pending port (PR follow-ups)
-
-These exist as production code in `deco-cx/apps/algolia/` and need a
-Deno → Node pass (npm specifiers, `commerce/types.ts` shared import,
-etc.). Tracked here so the next PR series has a clear scope:
-
-| Path | Original location |
-|---|---|
-| `loaders/product/list.ts` | `deco-cx/apps/algolia/loaders/product/list.ts` |
-| `loaders/product/listingPage.ts` | idem |
-| `loaders/product/suggestions.ts` | idem |
-| `actions/setup.ts` | `deco-cx/apps/algolia/actions/setup.ts` |
-| `actions/index/{product,wait}.ts` | `deco-cx/apps/algolia/actions/index/*` |
-| `utils/{highlight,product}.ts` | `deco-cx/apps/algolia/utils/*` |
-| `workflows/index/product.ts` | `deco-cx/apps/algolia/workflows/index/product.ts` |
-| `sections/Analytics/Algolia.tsx` | `deco-cx/apps/algolia/sections/Analytics/Algolia.tsx` |
-
-The site-side `src/packs/algolia/products/*` in a production Algolia storefront
-contains a storefront-specific transform layer that is not portable as-is.
-Once `loaders/product/*` lands here, the upstream tract can be reused;
-the storefront-specific overlays will keep living in the site.
-
-## Wiring in a site
-
-```ts
-// src/setup.ts
-import { initAlgoliaFromBlocks } from "@decocms/apps/algolia";
-import { blocks } from "./server/cms/blocks.gen";
-
-createSiteSetup({
-  // ...
-  initPlatform: (blocks) => {
-    initAlgoliaFromBlocks(blocks); // default block key: "deco-algolia"
-  },
-});
-```
-
-Then in your loaders:
-
-```ts
-import { getAlgoliaClient } from "@decocms/apps/algolia/client";
-
-export default async function loader(props, req) {
-  const client = getAlgoliaClient();
-  const { results } = await client.search([{
-    indexName: "products",
-    query: props.term,
-    params: { hitsPerPage: 12 },
-  }]);
-  return results[0].hits;
-}
-```
-
-The Secret-shaped `adminApiKey` in the CMS block
-(`{__resolveType: "website/loaders/secret.ts", name: "ADMIN_KEY"}`) is
-dereferenced via `process.env.ADMIN_KEY` at init time, matching how
-`magento/client.ts` handles secrets in this repo.

package/src/__tests__/client.test.ts

@@ -1,195 +0,0 @@
-/**
- * Tests for algolia/client.ts.
- *
- * The goal is to lock the contract that downstream sites depend on:
- *  - configureAlgolia stores config and surfaces it via getAlgoliaConfig
- *  - getAlgoliaConfig throws a useful error when init never happened
- *  - getAlgoliaClient builds the SDK lazily and caches the instance
- *  - initAlgoliaFromBlocks dereferences Secret-shaped admin keys via
- *    `process.env` so prod CMS blocks (`{__resolveType:
- *    "website/loaders/secret.ts", name: "ADMIN_KEY"}`) work
- *
- * The SDK itself is mocked — we don't want network or fetch polyfills
- * pulled into the test runner; we only care that we call into
- * `algoliasearch(applicationId, adminApiKey)` with the right args.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const algoliasearchSpy = vi.fn(() => ({ __mockClient: true }));
-
-vi.mock("algoliasearch", () => ({
-	algoliasearch: (...args: unknown[]) =>
-		algoliasearchSpy(...(args as Parameters<typeof algoliasearchSpy>)),
-}));
-
-// Importing after the mock so the production module picks up the
-// mocked SDK. resetModules() in beforeEach keeps module-global state
-// (cachedClient, config) isolated across tests.
-let mod: typeof import("../client");
-
-beforeEach(async () => {
-	algoliasearchSpy.mockClear();
-	vi.resetModules();
-	mod = await import("../client");
-});
-
-afterEach(() => {
-	delete process.env.TEST_ADMIN_KEY;
-});
-
-describe("configureAlgolia + getAlgoliaConfig", () => {
-	it("returns the most recently configured values", () => {
-		mod.configureAlgolia({ applicationId: "APP", searchApiKey: "S", adminApiKey: "A" });
-		expect(mod.getAlgoliaConfig()).toEqual({
-			applicationId: "APP",
-			searchApiKey: "S",
-			adminApiKey: "A",
-		});
-	});
-
-	it("throws a helpful error when called before init", () => {
-		expect(() => mod.getAlgoliaConfig()).toThrowError(/configureAlgolia/);
-	});
-});
-
-describe("getAlgoliaClient", () => {
-	it("constructs the SDK with applicationId + adminApiKey", () => {
-		mod.configureAlgolia({ applicationId: "APP_X", searchApiKey: "S", adminApiKey: "ADMIN" });
-		const client = mod.getAlgoliaClient();
-		expect(algoliasearchSpy).toHaveBeenCalledExactlyOnceWith("APP_X", "ADMIN");
-		expect(client).toEqual({ __mockClient: true });
-	});
-
-	it("caches the client across calls", () => {
-		mod.configureAlgolia({ applicationId: "APP_X", searchApiKey: "S", adminApiKey: "ADMIN" });
-		mod.getAlgoliaClient();
-		mod.getAlgoliaClient();
-		mod.getAlgoliaClient();
-		expect(algoliasearchSpy).toHaveBeenCalledOnce();
-	});
-
-	it("rebuilds the client after configureAlgolia is called again", () => {
-		mod.configureAlgolia({ applicationId: "APP_X", searchApiKey: "S", adminApiKey: "ADMIN1" });
-		mod.getAlgoliaClient();
-		mod.configureAlgolia({ applicationId: "APP_X", searchApiKey: "S", adminApiKey: "ADMIN2" });
-		mod.getAlgoliaClient();
-		expect(algoliasearchSpy).toHaveBeenCalledTimes(2);
-		expect(algoliasearchSpy).toHaveBeenNthCalledWith(2, "APP_X", "ADMIN2");
-	});
-
-	it("throws when applicationId is missing", () => {
-		mod.configureAlgolia({ applicationId: "", searchApiKey: "S", adminApiKey: "A" });
-		expect(() => mod.getAlgoliaClient()).toThrowError(/applicationId/);
-	});
-
-	it("falls back to searchApiKey when adminApiKey is empty", () => {
-		mod.configureAlgolia({ applicationId: "APP", searchApiKey: "SEARCH_ONLY", adminApiKey: "" });
-		mod.getAlgoliaClient();
-		expect(algoliasearchSpy).toHaveBeenCalledExactlyOnceWith("APP", "SEARCH_ONLY");
-	});
-
-	it("throws when both keys are empty", () => {
-		mod.configureAlgolia({ applicationId: "APP", searchApiKey: "", adminApiKey: "" });
-		expect(() => mod.getAlgoliaClient()).toThrowError(/adminApiKey or searchApiKey/);
-	});
-
-	it("prefers adminApiKey over searchApiKey when both present", () => {
-		mod.configureAlgolia({ applicationId: "APP", searchApiKey: "S", adminApiKey: "ADMIN" });
-		mod.getAlgoliaClient();
-		expect(algoliasearchSpy).toHaveBeenCalledExactlyOnceWith("APP", "ADMIN");
-	});
-});
-
-describe("initAlgoliaFromBlocks", () => {
-	it("returns false and skips configure() when block is absent", async () => {
-		const result = await mod.initAlgoliaFromBlocks({});
-		expect(result).toBe(false);
-		expect(() => mod.getAlgoliaConfig()).toThrowError(/configureAlgolia/);
-	});
-
-	it("reads applicationId + searchApiKey + adminApiKey from the block", async () => {
-		const result = await mod.initAlgoliaFromBlocks({
-			"deco-algolia": {
-				applicationId: "APP",
-				searchApiKey: "SEARCH",
-				adminApiKey: "ADMIN_STRING",
-			},
-		});
-		expect(result).toBe(true);
-		expect(mod.getAlgoliaConfig()).toEqual({
-			applicationId: "APP",
-			searchApiKey: "SEARCH",
-			adminApiKey: "ADMIN_STRING",
-		});
-	});
-
-	it("dereferences a Secret-shaped adminApiKey via process.env", async () => {
-		process.env.TEST_ADMIN_KEY = "from-env";
-		await mod.initAlgoliaFromBlocks({
-			"deco-algolia": {
-				applicationId: "APP",
-				searchApiKey: "SEARCH",
-				adminApiKey: {
-					__resolveType: "website/loaders/secret.ts",
-					name: "TEST_ADMIN_KEY",
-				},
-			},
-		});
-		expect(mod.getAlgoliaConfig().adminApiKey).toBe("from-env");
-	});
-
-	it("falls back to empty string when env var is unset", async () => {
-		await mod.initAlgoliaFromBlocks({
-			"deco-algolia": {
-				applicationId: "APP",
-				searchApiKey: "SEARCH",
-				adminApiKey: {
-					__resolveType: "website/loaders/secret.ts",
-					name: "UNDEFINED_ENV_VAR_DO_NOT_SET",
-				},
-			},
-		});
-		expect(mod.getAlgoliaConfig().adminApiKey).toBe("");
-	});
-
-	it("honors a custom block key", async () => {
-		await mod.initAlgoliaFromBlocks(
-			{
-				"my-algolia": {
-					applicationId: "X",
-					searchApiKey: "Y",
-					adminApiKey: "Z",
-				},
-			},
-			"my-algolia",
-		);
-		expect(mod.getAlgoliaConfig().applicationId).toBe("X");
-	});
-
-	// Encrypted-secret flow: the CMS block ships `{ encrypted, name }`,
-	// the framework's `resolveSecret` (from `@decocms/start/sdk/crypto`)
-	// is supposed to AES-CBC decrypt `encrypted` using `DECO_CRYPTO_KEY`.
-	// In a vitest worker `crypto.subtle` is available but the AES key
-	// material isn't shipped to the runner — without `DECO_CRYPTO_KEY`,
-	// `resolveSecret` skips the decrypt step and falls back to the env
-	// var. That fallback path is what this test pins: prod sites either
-	// set the env var on top OR (more commonly) rely on the decrypt to
-	// succeed against the worker's `DECO_CRYPTO_KEY` binding.
-	it("uses env var fallback when DECO_CRYPTO_KEY is unset and encrypted is present", async () => {
-		delete process.env.DECO_CRYPTO_KEY;
-		process.env.FALLBACK_ADMIN_KEY = "from-env-fallback";
-		await mod.initAlgoliaFromBlocks({
-			"deco-algolia": {
-				applicationId: "APP",
-				searchApiKey: "SEARCH",
-				adminApiKey: {
-					__resolveType: "website/loaders/secret.ts",
-					encrypted: "deadbeef",
-					name: "FALLBACK_ADMIN_KEY",
-				},
-			},
-		});
-		expect(mod.getAlgoliaConfig().adminApiKey).toBe("from-env-fallback");
-		delete process.env.FALLBACK_ADMIN_KEY;
-	});
-});

package/src/client.ts

@@ -1,133 +0,0 @@
-/**
- * Algolia client + config — module-global, set once at app boot.
- *
- * Mirrors `magento/client.ts` and `vtex/client.ts`'s `configureX` /
- * `getX` pattern so the same wiring contract works across commerce
- * apps. The SearchClient is constructed lazily on the first
- * `getAlgoliaClient()` call so the underlying `algoliasearch` SDK
- * (which pulls in fetch polyfills + an LRU) only loads when actually
- * used.
- *
- * Two reasons we don't pass config explicitly to every loader:
- *  1. CMS-resolved loader instances don't know where the config block
- *     lives; the site's `initAlgoliaFromBlocks(blocks)` adapter is the
- *     single source of truth.
- *  2. Matches the rest of @decocms/apps so a site touching VTEX,
- *     Magento, and Algolia has consistent muscle memory.
- */
-
-import { algoliasearch, type SearchClient } from "algoliasearch";
-
-import type { AlgoliaConfig } from "./types";
-
-// ---------------------------------------------------------------------------
-// Module-global state
-// ---------------------------------------------------------------------------
-
-let config: AlgoliaConfig | null = null;
-let cachedClient: SearchClient | null = null;
-
-export function configureAlgolia(c: AlgoliaConfig): void {
-	config = c;
-	// Reset the cached client so the next getAlgoliaClient() call picks
-	// up the new credentials. In practice this only happens during dev
-	// hot-reload of the setup file.
-	cachedClient = null;
-}
-
-export function getAlgoliaConfig(): AlgoliaConfig {
-	if (!config) {
-		throw new Error(
-			"[Algolia] configureAlgolia() must be called before loaders run. " +
-				"Wire it in your site's setup, e.g. configureAlgolia(blocks['deco-algolia']).",
-		);
-	}
-	return config;
-}
-
-/**
- * Returns the configured `SearchClient` from `algoliasearch`. The
- * instance is cached so all loaders/actions in a worker share one
- * client (and therefore one in-memory request cache).
- *
- * Prefers `adminApiKey` (broader scope — needed for indexing/settings
- * actions) but falls back to `searchApiKey` so search-only sites that
- * never set the admin secret as a worker env var still serve hits.
- * Both keys live in the same SDK instance because v4's SearchClient
- * doesn't expose a key swap; downstream write actions that require
- * admin scope should check `getAlgoliaConfig().adminApiKey` themselves
- * and surface a clear "admin key missing" error.
- */
-export function getAlgoliaClient(): SearchClient {
-	if (cachedClient) return cachedClient;
-	const c = getAlgoliaConfig();
-	if (!c.applicationId) {
-		throw new Error("[Algolia] applicationId is required.");
-	}
-	const key = c.adminApiKey || c.searchApiKey;
-	if (!key) {
-		throw new Error(
-			"[Algolia] Either adminApiKey or searchApiKey is required. " +
-				"Set ADMIN_KEY (or the env var your CMS block's Secret references) " +
-				"as a worker env var, or populate searchApiKey on the block.",
-		);
-	}
-	// algoliasearch v5 uses the global `fetch` and `crypto` APIs by
-	// default — works on Cloudflare Workers, Bun, Deno, modern Node.
-	// v4 (with crypto / node:http imports) does not run on Workers.
-	cachedClient = algoliasearch(c.applicationId, key);
-	return cachedClient;
-}
-
-// ---------------------------------------------------------------------------
-// CMS block adapter
-// ---------------------------------------------------------------------------
-
-/**
- * Best-effort init from a CMS block — mirrors `initMagentoFromBlocks`.
- *
- * Resolves `adminApiKey` via the shared `resolveSecret` from
- * `@decocms/start/sdk/crypto`, which walks: plain string → `.get()`
- * accessor → AES-CBC decrypt of `.encrypted` (using `DECO_CRYPTO_KEY`)
- * → `process.env[name]` fallback. Previously this init had its own
- * local helper that only consulted `process.env`, which meant any
- * site relying on the encrypted-secret round-trip (the production
- * Deco CMS default) silently produced `adminApiKey: ""` and
- * `getAlgoliaClient()` either threw or fell back to `searchApiKey`.
- *
- * Async because the AES decrypt is async — site setups must `await`
- * the call before any algolia loader fires.
- *
- * The block is conventionally keyed `deco-algolia` (matches the prod
- * Fresh sites' admin block name), but a custom key can be passed for
- * sites that named theirs differently. Returns true if the block was
- * found and applied, false otherwise.
- */
-export async function initAlgoliaFromBlocks(
-	blocks: Record<string, unknown>,
-	blockKey = "deco-algolia",
-): Promise<boolean> {
-	const block = blocks[blockKey] as Record<string, unknown> | undefined;
-	if (!block) return false;
-
-	const { resolveSecret } = await import("@decocms/blocks/sdk/crypto");
-
-	const applicationId = typeof block.applicationId === "string" ? block.applicationId : "";
-	const searchApiKey = typeof block.searchApiKey === "string" ? block.searchApiKey : "";
-
-	const adminApiKeyEnvName: string =
-		block.adminApiKey &&
-		typeof block.adminApiKey === "object" &&
-		typeof (block.adminApiKey as { name?: unknown }).name === "string"
-			? (block.adminApiKey as { name: string }).name
-			: "";
-	const adminApiKey = (await resolveSecret(block.adminApiKey, adminApiKeyEnvName)) ?? "";
-
-	configureAlgolia({ applicationId, searchApiKey, adminApiKey });
-	return true;
-}
-
-// Re-exported for convenience so consumers can `import { SearchClient }
-// from "@decocms/apps/algolia/client"` without depending on the npm
-// path explicitly.
-export type { SearchClient };

package/src/loaders/client.ts

@@ -1,22 +0,0 @@
-/**
- * Returns the configured Algolia SearchClient.
- *
- * Mirrors `apps/algolia/loaders/client.ts` (deco-cx/apps) so site code
- * doing `await invoke.algolia.loaders.client({})` keeps the same call
- * shape during the Fresh → TanStack migration. New code in the same
- * module can also `import { getAlgoliaClient } from
- * "@decocms/apps/algolia/client"` directly, skipping the invoke
- * round-trip when on the server.
- */
-
-import { getAlgoliaClient, type SearchClient } from "../client";
-
-/**
- * @title Algolia Search Client
- * @description Returns the SDK SearchClient configured at app boot.
- */
-export default function loader(): SearchClient {
-	return getAlgoliaClient();
-}
-
-export type { SearchClient };

package/src/types.ts

@@ -1,44 +0,0 @@
-/**
- * Shared Algolia types.
- *
- * Kept as a separate module so consumers can import types without
- * pulling in the `algoliasearch` runtime (which is only needed by the
- * client/loader code).
- */
-
-/**
- * Subset of the storefront-shaped Algolia config the app boots from.
- * Mirrors the original `apps/algolia/mod.ts` props shape so existing
- * CMS blocks (`{__resolveType: "site/apps/deco/algolia.ts", ...}`)
- * keep working byte-for-byte during the migration.
- */
-export interface AlgoliaConfig {
-	/**
-	 * Algolia application ID. Find it under
-	 * https://dashboard.algolia.com/account/api-keys/all
-	 */
-	applicationId: string;
-	/**
-	 * Search-only API key — safe to ship to the browser. Used by the
-	 * client-side search proxy and SSR loaders that don't need writes.
-	 */
-	searchApiKey: string;
-	/**
-	 * Admin API key (NEVER ship to the browser). Used by the SDK
-	 * instance because some operations (indexing, settings) require
-	 * admin scope. Server-side only.
-	 */
-	adminApiKey: string;
-}
-
-/**
- * Canonical Algolia index slugs used by Deco storefronts. Stays here
- * so loaders share the same type without each one redeclaring the
- * union. Sites with custom index names just pass strings (loaders
- * accept `string`, this constant union is for autocomplete).
- */
-export type Indices =
-	| "products"
-	| "products_price_asc"
-	| "products_price_desc"
-	| "products_query_suggestions";

package/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist"
-  },
-  "include": ["src/**/*"]
-}