okengine 0.3.6 → 0.4.3

package/src/docker/docker.test.ts

@@ -43,6 +43,29 @@ describe("image recipes", () => {
     expect(redis.match("redis:7")).toBe(true);
   });
 
+  test("meilisearch matches the official image and emits a http URL", () => {
+    expect(recipeFor("getmeili/meilisearch:v1.37").id).toBe("meilisearch");
+    const spec: ServiceSpec = {
+      role: "store.index",
+      serviceName: "store-index",
+      image: "getmeili/meilisearch:v1.37",
+      port: 7700,
+      hostPort: 7700,
+      credentials: { user: "oke", password: "meili-master-key", database: "oke" },
+    };
+    const applied = recipeFor(spec.image).apply(spec);
+    expect(applied.environment?.MEILI_MASTER_KEY).toBe("${OKE_STORE_INDEX_KEY}");
+    expect(applied.volumes).toContain("store-index-data:/meili_data");
+    const url = recipeFor(spec.image).url(spec, {
+      host: "127.0.0.1",
+      port: 7700,
+      user: "oke",
+      password: "meili-master-key",
+      database: "oke",
+    });
+    expect(url).toBe("http://127.0.0.1:7700");
+  });
+
   test("a new image recipe is ≤15 lines", async () => {
     const src = await Bun.file(`${import.meta.dir}/recipes/postgres.ts`).text();
     const exportLines = src
@@ -197,6 +220,24 @@ describe("deriveInfrastructure", () => {
     expect(formatStackEnv(result.stackEnv)).toContain("OKE_STORE_SQL_PASSWORD=");
   });
 
+  test("store.index meilisearch emits its own URL + master key env", () => {
+    const result = deriveInfrastructure({
+      images: { "store.index": "getmeili/meilisearch:v1.37" },
+      credentials: {
+        "store.index": { user: "oke", password: "meili-master-key", database: "oke" },
+      },
+      app: "skyport",
+    });
+    const yml = result.files.find((f) => f.path === "compose.store.index.yml")!.content;
+    expect(yml).toContain("getmeili/meilisearch:v1.37");
+    expect(yml).toContain("${OKE_STORE_INDEX_KEY}");
+    expect(yml).toContain("meili_data");
+    expect(yml).not.toContain("meili-master-key");
+    expect(result.stackEnv.OKE_STORE_INDEX_URL).toBe("http://127.0.0.1:7700");
+    expect(result.stackEnv.OKE_STORE_INDEX_KEY).toBe("meili-master-key");
+    expect(result.stackEnv.DATABASE_URL).toBeUndefined();
+  });
+
   test("emits protocol-specific env keys plus optional control notes", () => {
     const result = deriveInfrastructure({
       images: {

package/src/docker/recipes/index.ts

@@ -4,15 +4,23 @@
 
 import type { ImageRecipe } from "../types.ts";
 import { mailpit } from "./mailpit.ts";
+import { meilisearch } from "./meilisearch.ts";
 import { openbao } from "./openbao.ts";
 import { postgres } from "./postgres.ts";
 import { redis } from "./redis.ts";
 import { rustfs } from "./rustfs.ts";
 
 /** Default recipe catalogue. */
-export const builtinRecipes: readonly ImageRecipe[] = [postgres, redis, mailpit, rustfs, openbao];
+export const builtinRecipes: readonly ImageRecipe[] = [
+  postgres,
+  redis,
+  mailpit,
+  rustfs,
+  openbao,
+  meilisearch,
+];
 
-export { mailpit, openbao, postgres, redis, rustfs };
+export { mailpit, meilisearch, openbao, postgres, redis, rustfs };
 
 /**
  * Resolve the recipe for an image reference.

package/src/docker/recipes/meilisearch.ts

@@ -0,0 +1,31 @@
+/**
+ * Meilisearch image recipe — full-text search service (`getmeili/meilisearch`).
+ *
+ * Data lives on a named volume under `/meili_data`; the master key is injected
+ * via `${VAR}` (never cleartext in YAML). The official image is Alpine-based
+ * and musl-clean — the glibc binary gap only affects raw host installs.
+ */
+
+import type { ImageRecipe } from "../types.ts";
+
+/** Meilisearch FTS service. API on 7700. */
+export const meilisearch: ImageRecipe = {
+  id: "meilisearch",
+  port: 7700,
+  match: (i) => /meilisearch|getmeili/i.test(i),
+  apply: (s) => ({
+    environment: {
+      MEILI_MASTER_KEY: "${OKE_STORE_INDEX_KEY}",
+      MEILI_ENV: "${OKE_MEILI_ENV:-production}",
+      MEILI_NO_ANALYTICS: "true",
+    },
+    volumes: [`${s.serviceName}-data:/meili_data`],
+    healthcheck: {
+      test: ["CMD-SHELL", "wget -q -O /dev/null http://127.0.0.1:7700/health || exit 1"],
+      interval: "5s",
+      timeout: "3s",
+      retries: 12,
+    },
+  }),
+  url: (_s, c) => `http://${c.host}:${c.port}`,
+};

package/src/drivers/conformance.test.ts

@@ -9,10 +9,13 @@ import {
   runIndexConformance,
   runKvConformance,
   runSqlConformance,
+  runTextIndexConformance,
 } from "./conformance.ts";
 import { fsDriver } from "./fs.ts";
 import { libsqlDriver, libsqlIndexDriver } from "./libsql.ts";
 import { memoryFilesDriver, memoryIndexDriver, memoryKvDriver, memorySqlDriver } from "./memory.ts";
+import { meilisearchDriver } from "./meilisearch.ts";
+import { createMeilisearchFakeFetch } from "./meilisearch.test.ts";
 import { pgliteDriver } from "./pglite.ts";
 import { pgvectorDriver } from "./pgvector.ts";
 import { createPostgresFakeClient, postgresDriver } from "./postgres.ts";
@@ -24,7 +27,8 @@ describe("sql conformance", () => {
   test("memory", () => runSqlConformance(memorySqlDriver));
   test("sqlite", () => runSqlConformance(sqliteDriver, { url: ":memory:" }));
   test("libsql", () => runSqlConformance(libsqlDriver, { url: ":memory:" }));
-  test("pglite", () => runSqlConformance(pgliteDriver, { url: "memory://" }));
+  // pglite cold-starts WASM + extension load — slow disks / CI need > default 5s
+  test("pglite", () => runSqlConformance(pgliteDriver, { url: "memory://" }), 15_000);
   test("postgres (fake Bun.SQL client)", () =>
     runSqlConformance(postgresDriver, {
       client: createPostgresFakeClient(),
@@ -53,6 +57,15 @@ describe("index conformance", () => {
   test("libsql", () => runIndexConformance(libsqlIndexDriver, { dims: 3 }));
 });
 
+describe("text index conformance", () => {
+  test("meilisearch (injected fetch)", () =>
+    runTextIndexConformance(meilisearchDriver, {
+      url: "http://127.0.0.1:7700",
+      apiKey: "master-key",
+      fetch: createMeilisearchFakeFetch(),
+    }));
+});
+
 describe("protocol naming", () => {
   test("driver ids are protocols, never vendors", () => {
     const ids = [
@@ -69,6 +82,7 @@ describe("protocol naming", () => {
       memoryIndexDriver.id,
       pgvectorDriver.id,
       libsqlIndexDriver.id,
+      meilisearchDriver.id,
     ];
     expect(ids).toEqual([
       "memory",
@@ -84,6 +98,7 @@ describe("protocol naming", () => {
       "memory",
       "pgvector",
       "libsql",
+      "meilisearch",
     ]);
     for (const id of ids) {
       expect(id).not.toMatch(/neon|dragonfly|minio|upstash|cloudflare/i);

package/src/drivers/conformance.ts

@@ -8,7 +8,14 @@
 import { expect } from "bun:test";
 import { createSqlStoreHandle } from "../elements/store/sql-session.ts";
 import { defineTable } from "../elements/store/table.ts";
-import type { FilesDriver, IndexDriver, KvDriver, SqlDriver, SqlConnectOptions } from "./types.ts";
+import type {
+  FilesDriver,
+  KvDriver,
+  SqlDriver,
+  SqlConnectOptions,
+  TextIndexDriver,
+  VectorIndexDriver,
+} from "./types.ts";
 
 /** SQL conformance against one driver. */
 export async function runSqlConformance(
@@ -118,9 +125,9 @@ export async function runFilesConformance(
   }
 }
 
-/** Index conformance against one driver. */
+/** Vector index conformance against one driver. */
 export async function runIndexConformance(
-  driver: IndexDriver,
+  driver: VectorIndexDriver,
   openOpts: {
     name?: string;
     dims?: number;
@@ -147,3 +154,33 @@ export async function runIndexConformance(
     await index.close();
   }
 }
+
+/** Full-text index conformance against one driver. */
+export async function runTextIndexConformance(
+  driver: TextIndexDriver,
+  openOpts: {
+    name?: string;
+    url?: string;
+    apiKey?: string;
+    fetch?: typeof fetch;
+  } = {},
+): Promise<void> {
+  const index = await driver.open({
+    name: openOpts.name ?? "conf-text",
+    dims: 0,
+    url: openOpts.url,
+    apiKey: openOpts.apiKey,
+    fetch: openOpts.fetch,
+  });
+  try {
+    await index.upsert("d1", { id: "d1", title: "hello world" });
+    await index.upsert("d2", { id: "d2", title: "goodbye world" });
+    const found = await index.search("hello", { topK: 1 });
+    expect(found.hits.length).toBeGreaterThan(0);
+    expect(found.hits[0]?.id).toBe("d1");
+    expect(await index.delete("d1")).toBe(true);
+    expect(index.driverId).toBe(driver.id);
+  } finally {
+    await index.close();
+  }
+}

package/src/drivers/index.ts

@@ -23,12 +23,18 @@ export type {
   FilesDriver,
   IndexHit,
   IndexStore,
+  VectorIndexStore,
+  TextIndexStore,
+  TextIndexSearchOptions,
+  TextIndexSearchResult,
   IndexOpenOptions,
   IndexDriver,
+  VectorIndexDriver,
+  TextIndexDriver,
   StoreDriver,
   ClassificationMap,
 } from "./types.ts";
-export { classificationKey } from "./types.ts";
+export { classificationKey, indexDriverNeedsSql } from "./types.ts";
 
 export type {
   SignalDriverId,
@@ -79,6 +85,13 @@ export { pgvectorDriver, openPgvectorIndex } from "./pgvector.ts";
 
 export { libsqlDriver, connectLibsql, libsqlIndexDriver, openLibsqlIndex } from "./libsql.ts";
 
+export {
+  meilisearchDriver,
+  openMeilisearchIndex,
+  MeilisearchUnavailableError,
+  type MeilisearchIndexOptions,
+} from "./meilisearch.ts";
+
 export { pgliteDriver, connectPglite } from "./pglite.ts";
 
 export { memorySignalDriver, openMemorySignal } from "./signal-memory.ts";
@@ -107,7 +120,6 @@ export type { VaultDriverId, VaultOpenOptions, VaultBag, VaultDriver } from "./v
 export { memoryVaultDriver } from "./vault-memory.ts";
 export { envVaultDriver } from "./vault-env.ts";
 export { openbaoVaultDriver, OpenBaoUnavailableError } from "./vault-openbao.ts";
-export { infisicalVaultDriver } from "./vault-infisical.ts";
 export { managedVaultDriver } from "./vault-managed.ts";
 
 export type {

package/src/drivers/libsql.ts

@@ -13,14 +13,14 @@
 
 import { customType, sqliteTable, text } from "drizzle-orm/sqlite-core";
 import type {
-  IndexDriver,
   IndexHit,
   IndexOpenOptions,
-  IndexStore,
   SqlConnectOptions,
   SqlConnection,
   SqlDriver,
   SqlRow,
+  VectorIndexDriver,
+  VectorIndexStore,
 } from "./types.ts";
 
 /** `@libsql/client` is an optional peer — loaded only when this driver runs. */
@@ -100,7 +100,7 @@ const f32Blob = customType<{
  *
  * @param options - Name / dims / shared SQL connection
  */
-export async function openLibsqlIndex(options: IndexOpenOptions): Promise<IndexStore> {
+export async function openLibsqlIndex(options: IndexOpenOptions): Promise<VectorIndexStore> {
   const ownsSql = !options.sql;
   const sql = options.sql ?? (await connectLibsql({ url: options.url }));
   if (sql.driverId !== "libsql") {
@@ -172,7 +172,7 @@ export async function openLibsqlIndex(options: IndexOpenOptions): Promise<IndexS
 }
 
 /** Protocol-named libsql index driver. */
-export const libsqlIndexDriver: IndexDriver = {
+export const libsqlIndexDriver: VectorIndexDriver = {
   id: "libsql",
   facet: "index",
   open: openLibsqlIndex,

package/src/drivers/meilisearch.integration.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Live Meilisearch round-trip — Arabic + typo tolerance.
+ *
+ * The only acceptable evidence that Meilisearch actually handles Arabic (not
+ * just "supported" in marketing copy) is a real round-trip against a live
+ * server: index Arabic content, then search it — with and without the
+ * definite article (ال), with diacritics stripped, and with a Latin typo that
+ * typo-tolerance must forgive.
+ *
+ * Gated on a live server: set `OKE_TEST_MEILI_URL` (and optionally
+ * `OKE_TEST_MEILI_KEY`). Without it the whole suite skips, so unit runs never
+ * depend on Docker or a spawned binary.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { openMeilisearchIndex, type MeilisearchIndexOptions } from "./meilisearch.ts";
+
+const URL = process.env.OKE_TEST_MEILI_URL;
+const KEY = process.env.OKE_TEST_MEILI_KEY;
+if (!URL) {
+  console.log("skip: live meilisearch e2e (OKE_TEST_MEILI_URL not set)");
+}
+const live = URL ? test : test.skip;
+
+const opened: Array<{ close(): Promise<void> }> = [];
+afterEach(async () => {
+  while (opened.length > 0) {
+    await opened.pop()?.close();
+  }
+});
+
+async function liveIndex(name: string): ReturnType<typeof openMeilisearchIndex> {
+  const opts: MeilisearchIndexOptions = { name, dims: 0, url: URL, apiKey: KEY };
+  const index = await openMeilisearchIndex(opts);
+  opened.push(index);
+  return index;
+}
+
+describe("meilisearch live — arabic + typo tolerance", () => {
+  live("indexes and searches Arabic content (round-trip)", async () => {
+    const index = await liveIndex(`ar-${crypto.randomUUID().slice(0, 8)}`);
+    await index.upsert("d1", { title: "كتاب عن محركات البحث" });
+    await index.upsert("d2", { title: "مقال عن قواعد البيانات" });
+
+    const found = await index.search("البحث", { topK: 5 });
+    expect(found.hits.length).toBeGreaterThan(0);
+    expect(found.hits[0]?.id).toBe("d1");
+  });
+
+  live("matches a query without the definite article ال", async () => {
+    const index = await liveIndex(`ar-${crypto.randomUUID().slice(0, 8)}`);
+    await index.upsert("d1", { title: "الكتاب" });
+    // Charabia segments/normalises ال, so the bare stem should still match.
+    const found = await index.search("كتاب", { topK: 5 });
+    expect(found.hits.map((h) => h.id)).toContain("d1");
+  });
+
+  live("typo tolerance forgives a latin misspelling", async () => {
+    const index = await liveIndex(`en-${crypto.randomUUID().slice(0, 8)}`);
+    await index.upsert("d1", { title: "search engine" });
+    // One-transposition typo ("serach") must still hit the document.
+    const found = await index.search("serach", { topK: 5 });
+    expect(found.hits.map((h) => h.id)).toContain("d1");
+  });
+
+  live("filter + facets aggregate real results", async () => {
+    const index = await liveIndex(`fac-${crypto.randomUUID().slice(0, 8)}`);
+    await index.upsert("d1", { title: "red apple", color: "red" });
+    await index.upsert("d2", { title: "green apple", color: "green" });
+    const found = await index.search("apple", {
+      topK: 5,
+      filter: "color = red",
+      facets: ["color"],
+    });
+    expect(found.hits.map((h) => h.id)).toEqual(["d1"]);
+  });
+});

package/src/drivers/meilisearch.test.ts

@@ -0,0 +1,181 @@
+/**
+ * `meilisearch` index driver — task-waited writes, relevance search mapping,
+ * and fail-loud semantics against an injected fetch (never a live server).
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  MeilisearchUnavailableError,
+  meilisearchDriver,
+  openMeilisearchIndex,
+} from "./meilisearch.ts";
+
+/** A scripted Meilisearch over the wire — in-memory task + document store. */
+export function createMeilisearchFakeFetch(opts?: {
+  readonly failHealth?: boolean;
+  readonly failTask?: boolean;
+}): typeof fetch {
+  const documents = new Map<string, Record<string, unknown>>();
+  const taskResults = new Map<number, { fail: boolean }>();
+  let taskSeq = 0;
+
+  const json = (body: unknown, status = 200): Response =>
+    new Response(JSON.stringify(body), {
+      status,
+      headers: { "content-type": "application/json" },
+    });
+
+  const task = (type: string, fail: boolean): object => {
+    taskSeq += 1;
+    taskResults.set(taskSeq, { fail });
+    return { taskUid: taskSeq, indexUid: "kb", status: "enqueued", type };
+  };
+
+  return (async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const method = init?.method ?? "GET";
+
+    if (url.endsWith("/health")) {
+      if (opts?.failHealth) return json({ message: "down" }, 503);
+      return json({ status: "available" });
+    }
+
+    if (url.endsWith("/indexes") && method === "POST") {
+      return json(task("indexCreation", false), 202);
+    }
+
+    if (url.includes("/tasks/")) {
+      const taskUid = Number(url.split("/tasks/")[1]);
+      const fail = taskResults.get(taskUid)?.fail ?? false;
+      return json({
+        taskUid,
+        status: fail ? "failed" : "succeeded",
+        error: fail ? { message: "boom" } : null,
+      });
+    }
+
+    if (url.includes("/documents/") && method === "DELETE") {
+      const id = decodeURIComponent(url.split("/documents/")[1] ?? "");
+      if (!documents.delete(id)) return json({ message: "not found" }, 404);
+      return json(task("documentDeletion", opts?.failTask ?? false), 202);
+    }
+
+    if (url.endsWith("/documents") && method === "POST") {
+      const docs = JSON.parse(String(init?.body ?? "[]")) as Record<string, unknown>[];
+      if (!(opts?.failTask ?? false)) {
+        for (const doc of docs) documents.set(String(doc.id), doc);
+      }
+      return json(task("documentAdditionOrUpdate", opts?.failTask ?? false), 202);
+    }
+
+    if (url.endsWith("/search") && method === "POST") {
+      const {
+        q,
+        limit = 10,
+        facets,
+      } = JSON.parse(String(init?.body ?? "{}")) as {
+        q?: string;
+        limit?: number;
+        facets?: string[];
+      };
+      const query = (q ?? "").toLowerCase();
+      const hits = [...documents.values()]
+        .filter((doc) => query === "" || JSON.stringify(doc).toLowerCase().includes(query))
+        .slice(0, limit)
+        .map((doc) => ({ ...doc, _rankingScore: 0.95 }));
+      const facetDistribution: Record<string, Record<string, number>> = {};
+      for (const facet of facets ?? []) {
+        facetDistribution[facet] = { tagged: documents.size };
+      }
+      return json({
+        hits,
+        ...(facets && facets.length > 0 ? { facetDistribution } : {}),
+        estimatedTotalHits: hits.length,
+      });
+    }
+
+    return json({ message: `no route for ${method} ${url}` }, 404);
+  }) as typeof fetch;
+}
+
+describe("meilisearch driver", () => {
+  test("upsert → search maps _rankingScore into relevance score", async () => {
+    const index = await openMeilisearchIndex({
+      name: "kb",
+      dims: 0,
+      url: "http://127.0.0.1:7700",
+      apiKey: "master-key",
+      fetch: createMeilisearchFakeFetch(),
+    });
+    await index.upsert("d1", { title: "hello world", tag: "a" });
+    await index.upsert("d2", { title: "goodbye world", tag: "b" });
+
+    const found = await index.search("hello", { topK: 1 });
+    expect(found.hits).toHaveLength(1);
+    expect(found.hits[0]?.id).toBe("d1");
+    expect(found.hits[0]?.score).toBeGreaterThan(0);
+    expect(found.hits[0]?.meta).toMatchObject({ title: "hello world", tag: "a" });
+    await index.close();
+  });
+
+  test("facets return a facetDistribution", async () => {
+    const index = await openMeilisearchIndex({
+      name: "kb",
+      dims: 0,
+      url: "http://127.0.0.1:7700",
+      fetch: createMeilisearchFakeFetch(),
+    });
+    await index.upsert("d1", { title: "x", tag: "a" });
+    const found = await index.search("x", { facets: ["tag"] });
+    expect(found.facetDistribution).toEqual({ tag: { tagged: 1 } });
+    await index.close();
+  });
+
+  test("delete removes the document; missing id is false", async () => {
+    const index = await openMeilisearchIndex({
+      name: "kb",
+      dims: 0,
+      url: "http://127.0.0.1:7700",
+      fetch: createMeilisearchFakeFetch(),
+    });
+    await index.upsert("d1", { title: "x" });
+    expect(await index.delete("d1")).toBe(true);
+    expect(await index.delete("d1")).toBe(false);
+    await index.close();
+  });
+
+  test("missing URL fails loud (no memory fallback)", async () => {
+    await expect(openMeilisearchIndex({ name: "kb", dims: 0 })).rejects.toBeInstanceOf(
+      MeilisearchUnavailableError,
+    );
+  });
+
+  test("unhealthy server fails loud at open", async () => {
+    await expect(
+      openMeilisearchIndex({
+        name: "kb",
+        dims: 0,
+        url: "http://127.0.0.1:7700",
+        fetch: createMeilisearchFakeFetch({ failHealth: true }),
+      }),
+    ).rejects.toBeInstanceOf(MeilisearchUnavailableError);
+  });
+
+  test("a failed indexing task surfaces as a loud error, not a silent write", async () => {
+    const index = await openMeilisearchIndex({
+      name: "kb",
+      dims: 0,
+      url: "http://127.0.0.1:7700",
+      fetch: createMeilisearchFakeFetch({ failTask: true }),
+    });
+    await expect(index.upsert("d1", { title: "x" })).rejects.toBeInstanceOf(
+      MeilisearchUnavailableError,
+    );
+    await index.close();
+  });
+
+  test("driver id + facet", () => {
+    expect(meilisearchDriver.id).toBe("meilisearch");
+    expect(meilisearchDriver.facet).toBe("index");
+  });
+});