@lde/search-api-server 0.0.1

package/README.md

@@ -0,0 +1,138 @@
+# @lde/search-api-server
+
+The served [@lde/search](../search) API as a bootable process and prebuilt
+Docker image: mount a schema-declaration module, point it at Typesense, and it
+serves `/graphql` – POST execution, the self-contained playground, the SDL –
+plus `/health`, with CORS and depth/cost limits on by default.
+
+This is the composition layer
+([#600](https://github.com/ldelements/lde/issues/600), layer 3) that binds the
+engine-agnostic [`@lde/search-api-graphql`](../search-api-graphql) handler
+(layer 2) to the [`@lde/search-typesense`](../search-typesense) engine. Use it
+for turnkey, non-JS and ops-driven deployments; a JS host that wants custom
+GraphQL fields mounts the handler itself instead (or builds `FROM` this image).
+
+## Run
+
+```sh
+docker run --publish 4000:4000 \
+  --volume "$(pwd)/search-schema.mjs:/config/search-schema.mjs:ro" \
+  --env TYPESENSE_HOST=typesense.internal \
+  --env TYPESENSE_API_KEY=search-only-key \
+  ghcr.io/ldelements/search-api-server
+```
+
+Or without Docker (the same environment variables apply):
+
+```sh
+npx @lde/search-api-server
+```
+
+## The schema module
+
+The mounted module default-exports the deployment’s search type declarations as
+**plain data** – it must not import `@lde/search` (bare specifiers do not
+resolve from a mounted file), and does not need to: the server validates the
+declarations at boot, exactly as it would a SHACL generator’s output. Optional
+functions (`derive`, `transform`) are allowed – it is a real JS module, only
+without imports; they are projection-time declarations a serving process never
+calls, carried so one module can drive both the indexer and this API.
+
+Authoring in TypeScript works fine: compile the module to `.mjs` first
+(`tsc` or esbuild) and mount the output – with `satisfies SearchType[]` you
+get the full compile-time checking, and functions survive compilation. If the
+module must import, bundle it (e.g. esbuild) before mounting.
+
+```js
+// search-schema.mjs
+export default [
+  {
+    name: 'Dataset',
+    class: 'http://www.w3.org/ns/dcat#Dataset',
+    fields: [
+      {
+        name: 'title',
+        kind: 'text',
+        locales: ['nl', 'en'],
+        output: true,
+        searchable: { weight: 5 },
+      },
+      {
+        name: 'keyword',
+        kind: 'keyword',
+        array: true,
+        facetable: true,
+        output: true,
+      },
+    ],
+  },
+];
+
+// Optional: forwarded to buildGraphQLSchema (per-type options, maxPerPage, …).
+export const schemaOptions = { maxPerPage: 50 };
+
+// Optional: forwarded to createTypesenseSearchEngine (collection overrides, …).
+export const engineOptions = {};
+```
+
+Once the SHACL + `search:` generator lands
+([#495](https://github.com/ldelements/lde/issues/495)), mounted SHACL becomes
+an additional source for the same schema.
+
+## Configuration
+
+| Variable             | Default                     | Meaning                                            |
+| -------------------- | --------------------------- | -------------------------------------------------- |
+| `SCHEMA_MODULE`      | `/config/search-schema.mjs` | Path of the mounted schema-declaration module      |
+| `PORT`               | `4000`                      | TCP port the server binds                          |
+| `GRAPHQL_ENDPOINT`   | `/graphql`                  | Path serving GraphQL, the playground and the SDL   |
+| `PLAYGROUND`         | `true`                      | Serve the playground on GET (`false`/`0` disables) |
+| `MAX_DEPTH`          | handler default (15)        | Query depth cap                                    |
+| `MAX_COST`           | handler default (5000)      | Query cost cap                                     |
+| `TYPESENSE_HOST`     | **required**                | Typesense host                                     |
+| `TYPESENSE_PORT`     | `8108`                      | Typesense port                                     |
+| `TYPESENSE_PROTOCOL` | `http`                      | `http` or `https`                                  |
+| `TYPESENSE_API_KEY`  | **required**                | Use a search-only key: the server only ever reads  |
+
+A misconfigured boot reports **all** problems in one error, not one per crash
+loop.
+
+## Endpoints
+
+- `POST /graphql` – GraphQL execution.
+- `GET /graphql` – the self-contained playground (no external CDN, no framing
+  headers, so a docs site can `<iframe>` it as a live client).
+- `GET /graphql?sdl` – the printed SDL: the contract without a running
+  introspection query.
+- `GET /health` – liveness; the Docker image’s `HEALTHCHECK` uses it.
+- `GET /` – redirects to the endpoint.
+
+## Building the image
+
+The image is built from the workspace’s own outputs – the compiled package,
+the same-commit builds of its `@lde/*` dependencies and a pruned lockfile –
+never from npm, so it exists for any commit
+([ADR 15](../../docs/decisions/0015-ship-the-served-search-api-as-a-docker-image-built-from-the-workspace.md)):
+
+```sh
+npx nx run @lde/search-api-server:docker:build   # → packages-search-api-server
+npx nx run @lde/search-api-server:docker:smoke   # boots it and probes /health + ?sdl
+```
+
+CI runs `docker:smoke` for affected PRs; each release tag rebuilds and pushes
+`ghcr.io/ldelements/search-api-server:<version>` (`.github/workflows/docker.yml`).
+
+## Programmatic use
+
+The bin is a thin wrapper over the exported API, usable in tests or a custom
+boot:
+
+```ts
+import {
+  configFromEnvironment,
+  createSearchApiServer,
+} from '@lde/search-api-server';
+
+const server = await createSearchApiServer(configFromEnvironment(process.env));
+const port = await server.start();
+```

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { configFromEnvironment } from './config.js';
+import { createSearchApiServer } from './server.js';
+const { version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+try {
+    const config = configFromEnvironment(process.env);
+    const server = await createSearchApiServer(config);
+    const port = await server.start();
+    console.info(`@lde/search-api-server ${version} serving ${config.graphqlEndpoint} on port ${port}.`);
+    const shutdown = (signal) => {
+        console.info(`Received ${signal}; shutting down.`);
+        void server.stop().then(() => process.exit(0));
+    };
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    process.on('SIGINT', () => shutdown('SIGINT'));
+}
+catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+}

package/dist/config.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The server’s complete runtime configuration, read from environment
+ * variables ({@link configFromEnvironment}) – the contract of the Docker
+ * image. Everything engine- or schema-shaped (query defaults, collection
+ * overrides, per-type GraphQL options) lives in the mounted schema module
+ * instead, next to the declarations it configures.
+ */
+export interface ServerConfig {
+    /** Path of the mounted schema-declaration module (`SCHEMA_MODULE`). */
+    readonly schemaModulePath: string;
+    /** TCP port the HTTP server binds (`PORT`). */
+    readonly port: number;
+    /** Path serving GraphQL, the playground and the SDL (`GRAPHQL_ENDPOINT`). */
+    readonly graphqlEndpoint: string;
+    /** Serve the playground on GET requests to the endpoint (`PLAYGROUND`). */
+    readonly playground: boolean;
+    /** Query depth cap (`MAX_DEPTH`); the handler’s default when absent. */
+    readonly maxDepth?: number;
+    /** Query cost cap (`MAX_COST`); the handler’s default when absent. */
+    readonly maxCost?: number;
+    /** Where the Typesense engine reads (`TYPESENSE_*`). */
+    readonly typesense: TypesenseConnection;
+}
+/** Connection details of the Typesense node the engine searches. */
+export interface TypesenseConnection {
+    readonly host: string;
+    readonly port: number;
+    readonly protocol: 'http' | 'https';
+    /** Use a search-only key: the server only ever reads. */
+    readonly apiKey: string;
+}
+/**
+ * Read the {@link ServerConfig} from environment variables. Reports **all**
+ * problems in one error – a misconfigured deployment learns everything
+ * wrong with it from a single boot attempt, not one variable per crash loop.
+ */
+export declare function configFromEnvironment(environment: Readonly<Record<string, string | undefined>>): ServerConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,uEAAuE;IACvE,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,2EAA2E;IAC3E,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,sEAAsE;IACtE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,wDAAwD;IACxD,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAC;CACzC;AAED,oEAAoE;AACpE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IACpC,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,GACxD,YAAY,CA4Dd"}

package/dist/config.js

@@ -0,0 +1,54 @@
+/**
+ * Read the {@link ServerConfig} from environment variables. Reports **all**
+ * problems in one error – a misconfigured deployment learns everything
+ * wrong with it from a single boot attempt, not one variable per crash loop.
+ */
+export function configFromEnvironment(environment) {
+    const problems = [];
+    const required = (name) => {
+        const value = environment[name];
+        if (value === undefined || value.length === 0) {
+            problems.push(`${name} is required`);
+            return '';
+        }
+        return value;
+    };
+    const integer = (name, fallback) => {
+        const value = environment[name];
+        if (value === undefined || value.length === 0) {
+            return fallback;
+        }
+        const parsed = Number(value);
+        if (!Number.isInteger(parsed) || parsed < 0) {
+            problems.push(`${name} must be a non-negative integer, got “${value}”`);
+            return fallback;
+        }
+        return parsed;
+    };
+    const graphqlEndpoint = environment['GRAPHQL_ENDPOINT'] ?? '/graphql';
+    if (!graphqlEndpoint.startsWith('/')) {
+        problems.push(`GRAPHQL_ENDPOINT must be an absolute path, got “${graphqlEndpoint}”`);
+    }
+    const protocol = environment['TYPESENSE_PROTOCOL'] ?? 'http';
+    if (protocol !== 'http' && protocol !== 'https') {
+        problems.push(`TYPESENSE_PROTOCOL must be “http” or “https”, got “${protocol}”`);
+    }
+    const config = {
+        schemaModulePath: environment['SCHEMA_MODULE'] ?? '/config/search-schema.mjs',
+        port: integer('PORT', 4000),
+        graphqlEndpoint,
+        playground: !['false', '0'].includes((environment['PLAYGROUND'] ?? '').toLowerCase()),
+        maxDepth: integer('MAX_DEPTH'),
+        maxCost: integer('MAX_COST'),
+        typesense: {
+            host: required('TYPESENSE_HOST'),
+            port: integer('TYPESENSE_PORT', 8108),
+            protocol: protocol,
+            apiKey: required('TYPESENSE_API_KEY'),
+        },
+    };
+    if (problems.length > 0) {
+        throw new Error(`Invalid configuration:\n${problems.map((problem) => `- ${problem}`).join('\n')}`);
+    }
+    return config;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { createSearchApiServer } from './server.js';
+export type { SearchApiServer } from './server.js';
+export { configFromEnvironment } from './config.js';
+export type { ServerConfig, TypesenseConnection } from './config.js';
+export { loadSchemaModule } from './schema-module.js';
+export type { SchemaModule } from './schema-module.js';
+//# 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":"AAIA,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+// The bootable served search API: the composition layer binding the
+// engine-agnostic @lde/search-api-graphql handler to a Typesense engine, a
+// mounted schema-declaration module and environment config. The `search-api-server`
+// bin (src/cli.ts) and the Docker image are thin wrappers over these.
+export { createSearchApiServer } from './server.js';
+export { configFromEnvironment } from './config.js';
+export { loadSchemaModule } from './schema-module.js';

package/dist/schema-module.d.ts

@@ -0,0 +1,34 @@
+import type { SearchSchema } from '@lde/search';
+import type { BuildGraphQLSchemaOptions } from '@lde/search-api-graphql';
+import type { TypesenseSearchEngineOptions } from '@lde/search-typesense';
+/**
+ * What the mounted module declares: the deployment’s whole search
+ * declaration, plus the schema- and engine-shaped options that belong next to
+ * it. The module is **plain data with optional functions** (`derive`,
+ * `transform`) – it cannot `import '@lde/search'` (bare specifiers do not
+ * resolve from a mounted file), and does not need to: the declarations are
+ * validated here, the way a SHACL generator’s output would be. Once the
+ * SHACL + `search:` generator exists
+ * ([#495](https://github.com/ldelements/lde/issues/495)), a SHACL mount
+ * becomes an additional source for the same result.
+ */
+export interface SchemaModule {
+    /** The validated schema built from the module’s default export. */
+    readonly searchSchema: SearchSchema;
+    /** The module’s optional `schemaOptions` export, forwarded to
+     *  `buildGraphQLSchema` (per-type options, language order, `maxPerPage`). */
+    readonly schemaOptions?: BuildGraphQLSchemaOptions;
+    /** The module’s optional `engineOptions` export, forwarded to
+     *  `createTypesenseSearchEngine` (collection overrides, query knobs). */
+    readonly engineOptions?: TypesenseSearchEngineOptions;
+}
+/**
+ * Load and validate a mounted schema-declaration module
+ * (`@lde/search/module`’s {@link loadDeclarations | loadSchemaModule} – the
+ * loader the indexer image shares, so both sides mount the same file), then
+ * validate the read side’s optional exports. Throws with the module path in
+ * the message for every failure mode, so a bad mount fails the boot with a
+ * diagnosis, never the first query.
+ */
+export declare function loadSchemaModule(modulePath: string): Promise<SchemaModule>;
+//# sourceMappingURL=schema-module.d.ts.map

package/dist/schema-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-module.d.ts","sourceRoot":"","sources":["../src/schema-module.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,uBAAuB,CAAC;AAE1E;;;;;;;;;;GAUG;AACH,MAAM,WAAW,YAAY;IAC3B,mEAAmE;IACnE,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IACpC;iFAC6E;IAC7E,QAAQ,CAAC,aAAa,CAAC,EAAE,yBAAyB,CAAC;IACnD;6EACyE;IACzE,QAAQ,CAAC,aAAa,CAAC,EAAE,4BAA4B,CAAC;CACvD;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,YAAY,CAAC,CAOvB"}

package/dist/schema-module.js

@@ -0,0 +1,27 @@
+import { loadSchemaModule as loadDeclarations } from '@lde/search/module';
+/**
+ * Load and validate a mounted schema-declaration module
+ * (`@lde/search/module`’s {@link loadDeclarations | loadSchemaModule} – the
+ * loader the indexer image shares, so both sides mount the same file), then
+ * validate the read side’s optional exports. Throws with the module path in
+ * the message for every failure mode, so a bad mount fails the boot with a
+ * diagnosis, never the first query.
+ */
+export async function loadSchemaModule(modulePath) {
+    const { schema, moduleExports } = await loadDeclarations(modulePath);
+    return {
+        searchSchema: schema,
+        schemaOptions: optionalObject(moduleExports, 'schemaOptions', modulePath),
+        engineOptions: optionalObject(moduleExports, 'engineOptions', modulePath),
+    };
+}
+function optionalObject(moduleExports, name, modulePath) {
+    const value = moduleExports[name];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error(`Schema module “${modulePath}” export “${name}” must be an object.`);
+    }
+    return value;
+}

package/dist/server.d.ts

@@ -0,0 +1,19 @@
+import type { ServerConfig } from './config.js';
+/** The bootable server: construct with {@link createSearchApiServer}. */
+export interface SearchApiServer {
+    /** Start listening on the configured port; resolves with the bound port
+     *  (useful with `port: 0`, which binds an ephemeral one). */
+    start(): Promise<number>;
+    /** Stop accepting connections and close the server. */
+    stop(): Promise<void>;
+}
+/**
+ * Compose the served search API from a {@link ServerConfig}: load and
+ * validate the mounted schema module, bind the Typesense engine, build the
+ * GraphQL handler, and wrap it all in a `node:http` server that also answers
+ * `GET /health` (liveness) and redirects `/` to the endpoint. Every
+ * misconfiguration – an invalid schema, an underivable collection name
+ * – throws here, at boot, never on the first query.
+ */
+export declare function createSearchApiServer(config: ServerConfig): Promise<SearchApiServer>;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC9B;iEAC6D;IAC7D,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACzB,uDAAuD;IACvD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,eAAe,CAAC,CA8D1B"}

package/dist/server.js

@@ -0,0 +1,62 @@
+import { createServer } from 'node:http';
+import { createServerAdapter } from '@whatwg-node/server';
+import { Client } from 'typesense';
+import { createSearchGraphQLHandler } from '@lde/search-api-graphql';
+import { createTypesenseSearchEngine } from '@lde/search-typesense';
+import { loadSchemaModule } from './schema-module.js';
+/**
+ * Compose the served search API from a {@link ServerConfig}: load and
+ * validate the mounted schema module, bind the Typesense engine, build the
+ * GraphQL handler, and wrap it all in a `node:http` server that also answers
+ * `GET /health` (liveness) and redirects `/` to the endpoint. Every
+ * misconfiguration – an invalid schema, an underivable collection name
+ * – throws here, at boot, never on the first query.
+ */
+export async function createSearchApiServer(config) {
+    const { searchSchema, schemaOptions, engineOptions } = await loadSchemaModule(config.schemaModulePath);
+    const client = new Client({
+        nodes: [
+            {
+                host: config.typesense.host,
+                port: config.typesense.port,
+                protocol: config.typesense.protocol,
+            },
+        ],
+        apiKey: config.typesense.apiKey,
+    });
+    const engine = createTypesenseSearchEngine(client, searchSchema, engineOptions);
+    const graphql = createSearchGraphQLHandler({
+        searchSchema,
+        engine,
+        schemaOptions,
+        graphqlEndpoint: config.graphqlEndpoint,
+        playground: config.playground,
+        maxDepth: config.maxDepth,
+        maxCost: config.maxCost,
+    });
+    const adapter = createServerAdapter((request) => {
+        const url = new URL(request.url);
+        if (url.pathname === '/health') {
+            return Response.json({ status: 'ok' });
+        }
+        if (url.pathname === '/') {
+            return Response.redirect(new URL(config.graphqlEndpoint, url.origin).href, 302);
+        }
+        return graphql(request);
+    });
+    const server = createServer(adapter);
+    return {
+        start: () => new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(config.port, () => {
+                resolve(server.address().port);
+            });
+        }),
+        stop: () => new Promise((resolve, reject) => {
+            server.close((error) => (error ? reject(error) : resolve()));
+            // In-flight requests finish; idle keep-alive sockets would otherwise
+            // hold the close (and a rolling restart) open indefinitely.
+            server.closeIdleConnections();
+        }),
+    };
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@lde/search-api-server",
+  "version": "0.0.1",
+  "description": "The served @lde/search API as a bootable process and prebuilt Docker image: loads a mounted schema-declaration module and Typesense connection details from the environment, then serves /graphql (execution, playground, SDL) plus /health over node:http. The composition layer that binds the engine-agnostic @lde/search-api-graphql handler to @lde/search-typesense – for turnkey, non-JS and ops-driven deployments.",
+  "repository": {
+    "url": "git+https://github.com/ldelements/lde.git",
+    "directory": "packages/search-api-server"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "development": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "search-api-server": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "@lde/search": "^0.12.2",
+    "@lde/search-api-graphql": "^0.12.2",
+    "@lde/search-typesense": "^0.15.4",
+    "@whatwg-node/server": "^0.11.0",
+    "tslib": "^2.3.0",
+    "typesense": "^3.0.6"
+  },
+  "nx": {
+    "targets": {
+      "docker:stage": {
+        "options": {
+          "cwd": "{projectRoot}",
+          "command": "rm -rf dist-docker && mkdir dist-docker && cp package.json dist-docker/ && cp -R dist dist-docker/dist"
+        }
+      },
+      "copy-workspace-modules": {},
+      "prune-lockfile": {},
+      "docker:lockfile": {},
+      "docker:smoke": {
+        "executor": "nx:run-commands",
+        "dependsOn": [
+          "docker:build"
+        ],
+        "cache": false,
+        "options": {
+          "command": "./tools/docker-smoke.sh packages-search-api-server"
+        }
+      }
+    }
+  }
+}