@decocms/apps-algolia 8.1.0-next.0 → 8.1.0-next.2

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+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 declare class AlgoliaError extends Error {
+    readonly operation: string;
+    readonly status: number;
+    constructor(operation: string, status: number);
+}
+export declare function createAlgoliaClient(config: AlgoliaClientConfig, options?: {
+    fetch?: typeof globalThis.fetch;
+}): {
+    /** Runs several queries, on one or more indices, in one request. */
+    search<T = Record<string, unknown>>(requests: AlgoliaSearchRequest[]): Promise<{
+        results: AlgoliaSearchResponse<T>[];
+    }>;
+};
+export type AlgoliaClient = ReturnType<typeof createAlgoliaClient>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,sFAAsF;IACtF,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,uHAAuH;AACvH,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B;AAED,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAC;AAE/E,MAAM,WAAW,qBAAqB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAChE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAChD,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B;AAED,qBAAa,YAAa,SAAQ,KAAK;IAEnC,QAAQ,CAAC,SAAS,EAAE,MAAM;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM;IAFzB,YACW,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EAGxB;CACF;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;CAAO;IAwB/C,oEAAoE;IACpE,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YACtB,oBAAoB,EAAE,GAC/B,OAAO,CAAC;QAAE,OAAO,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAAE,CAAA;KAAE,CAAC;EAItD;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/index.js

@@ -0,0 +1,48 @@
+/**
+ * `@decocms/apps-algolia`: a thin client for the Algolia Search REST API.
+ * See /next/upstream-clients.
+ *
+ * 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.
+ */
+import { createInstrumentedFetch } from "@decocms/blocks/fetch";
+export class AlgoliaError extends Error {
+    operation;
+    status;
+    constructor(operation, status) {
+        super(`algolia ${operation} failed with HTTP ${status}`);
+        this.operation = operation;
+        this.status = status;
+    }
+}
+export function createAlgoliaClient(config, options = {}) {
+    // 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(operation, path, body) {
+        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());
+    }
+    return {
+        /** Runs several queries, on one or more indices, in one request. */
+        search(requests) {
+            return post("search", "/1/indexes/*/queries", { requests });
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAgChE,MAAM,OAAO,YAAa,SAAQ,KAAK;IAE1B,SAAS;IACT,MAAM;IAFjB,YACW,SAAiB,EACjB,MAAc;QAEvB,KAAK,CAAC,WAAW,SAAS,qBAAqB,MAAM,EAAE,CAAC,CAAC;yBAHhD,SAAS;sBACT,MAAM;IAGjB,CAAC;CACF;AAED,MAAM,UAAU,mBAAmB,CACjC,MAA2B,EAC3B,OAAO,GAAwC,EAAE;IAEjD,8FAA8F;IAC9F,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC;QAC9C,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,MAAM,OAAO,GAAG,uBAAuB,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;IACvF,MAAM,IAAI,GAAG,WAAW,MAAM,CAAC,aAAa,kBAAkB,CAAC;IAE/D,KAAK,UAAU,IAAI,CAAI,SAAiB,EAAE,IAAY,EAAE,IAAa;QACnE,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,IAAI,GAAG,IAAI,EAAE,EAAE;YAC/C,SAAS;YACT,MAAM,EAAE,MAAM;YACd,OAAO,EAAE;gBACP,cAAc,EAAE,kBAAkB;gBAClC,0BAA0B,EAAE,MAAM,CAAC,aAAa;gBAChD,mBAAmB,EAAE,MAAM,CAAC,MAAM;aACnC;YACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;SAC3B,CAAC,CAAC;QACH,IAAI,CAAC,QAAQ,CAAC,EAAE;YAAE,MAAM,IAAI,YAAY,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;QACrE,OAAO,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAM,CAAC;IACtC,CAAC;IAED,OAAO;QACL,oEAAoE;QACpE,MAAM,CACJ,QAAgC;YAEhC,OAAO,IAAI,CAAC,QAAQ,EAAE,sBAAsB,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC9D,CAAC;KACF,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/apps-algolia",
-  "version": "8.1.0-next.0",
+  "version": "8.1.0-next.2",
   "type": "module",
   "description": "Thin client for the Algolia Search REST API",
   "repository": {
@@ -8,34 +8,29 @@
     "url": "https://github.com/decocms/blocks.git",
     "directory": "packages/apps-algolia"
   },
-  "main": "./src/index.ts",
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/__tests__"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts",
-    "./client": "./src/client.ts",
-    "./types": "./src/types.ts",
-    "./loaders/*": "./src/loaders/*.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "source": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
   },
   "scripts": {
-    "build": "tsc",
+    "build": "node ../../scripts/tsc.mjs --clean dist -p tsconfig.build.json",
+    "prepack": "npm run build",
     "test": "vitest run --root ../.. packages/apps-algolia/",
-    "typecheck": "tsc --noEmit",
-    "lint:unused": "knip"
+    "typecheck": "node ../../scripts/tsc.mjs -p tsconfig.json"
   },
   "dependencies": {
-    "@decocms/blocks": "8.1.0-next.0"
-  },
-  "peerDependencies": {
-    "algoliasearch": "^5"
-  },
-  "peerDependenciesMeta": {
-    "algoliasearch": {
-      "optional": true
-    }
-  },
-  "devDependencies": {
-    "algoliasearch": "^5.53.0",
-    "knip": "^5.86.0",
-    "typescript": "^5.9.0"
+    "@decocms/blocks": "8.1.0-next.2"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",

package/src/index.ts

@@ -5,11 +5,7 @@
  * 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 framework binding's job.
- *
- * The v7 SDK wiring (`configureAlgolia`, `getAlgoliaClient`,
- * `initAlgoliaFromBlocks`) stays on the `./client` and `./loaders/client`
- * subpaths for v7 sites; it needs the optional `algoliasearch` peer.
+ * response cache: caching upstream data is the site's job.
  */
 import { createInstrumentedFetch } from "@decocms/blocks/fetch";
 
@@ -54,7 +50,7 @@ export class AlgoliaError extends Error {
 
 export function createAlgoliaClient(
   config: AlgoliaClientConfig,
-  options: { fetch?: typeof fetch } = {},
+  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))

package/src/README.md

@@ -1,94 +0,0 @@
-# Algolia app — initial scaffold
-
-> **Next major:** the package root exports `createAlgoliaClient`, a thin
-> client over the Algolia REST API built on `@decocms/blocks/fetch`
-> (see `/next/upstream-clients`). Everything below is the v7 surface, which
-> stays on the `./client`, `./loaders/client` and `./types` subpaths.
-
-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/client";
-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/__tests__/searchClient.test.ts

@@ -1,63 +0,0 @@
-/**
- * The v8 Algolia client (/next/upstream-clients): typed REST calls through
- * the instrumented fetch, credentials in headers, errors without bodies.
- */
-import { describe, expect, it, vi } from "vitest";
-import { AlgoliaError, createAlgoliaClient } from "../index";
-
-function fakeFetch(status: number, body: unknown) {
-  return vi.fn(
-    async (_input: string | URL | Request, _init?: RequestInit) =>
-      new Response(JSON.stringify(body), { status }),
-  );
-}
-
-const config = { applicationId: "APPID", apiKey: "search-key" };
-
-describe("createAlgoliaClient", () => {
-  it("search posts every query to the multi-query endpoint", async () => {
-    const fetch = fakeFetch(200, { results: [{ hits: [{ objectID: "1" }], nbHits: 1 }] });
-    const algolia = createAlgoliaClient(config, { fetch });
-
-    const { results } = await algolia.search([
-      { indexName: "products", query: "linen shirt", hitsPerPage: 12 },
-    ]);
-
-    expect(results[0].hits[0].objectID).toBe("1");
-    const [url, init] = fetch.mock.calls[0];
-    expect(String(url)).toBe("https://APPID-dsn.algolia.net/1/indexes/*/queries");
-    expect(init?.method).toBe("POST");
-    expect(init?.headers).toMatchObject({
-      "x-algolia-application-id": "APPID",
-      "x-algolia-api-key": "search-key",
-    });
-    expect(JSON.parse(String(init?.body))).toEqual({
-      requests: [{ indexName: "products", query: "linen shirt", hitsPerPage: 12 }],
-    });
-  });
-
-  it("rejects an applicationId that would change the host the key is sent to", () => {
-    expect(() =>
-      createAlgoliaClient({ applicationId: "evil.example/#", apiKey: "search-key" }),
-    ).toThrow("invalid applicationId");
-  });
-
-  it("throws the operation and status, never the body or the key", async () => {
-    const fetch = fakeFetch(403, { message: "Invalid API key search-key" });
-    const algolia = createAlgoliaClient(config, { fetch });
-
-    const error = await algolia.search([{ indexName: "products" }]).catch((e: unknown) => e);
-
-    expect(error).toBeInstanceOf(AlgoliaError);
-    expect(error).toMatchObject({ operation: "search", status: 403 });
-    expect((error as Error).message).not.toContain("search-key");
-  });
-
-  it("does not retry", async () => {
-    const fetch = fakeFetch(503, {});
-    const algolia = createAlgoliaClient(config, { fetch });
-
-    await expect(algolia.search([{ indexName: "products" }])).rejects.toThrow(AlgoliaError);
-    expect(fetch).toHaveBeenCalledTimes(1);
-  });
-});

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/**/*"]
-}