@venizia/ignis-connectors 0.2.0-0

package/dist/esm/search/core/controllers/abstract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract.d.ts","sourceRoot":"","sources":["../../../../../src/search/core/controllers/abstract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAE7D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAExC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAE9E,6MAA6M;AAC7M,8BAAsB,wBAAwB,CAC5C,OAAO,SAAS,cAAc,CAAC,gBAAgB,CAAC,GAAG,cAAc,CAAC,gBAAgB,CAAC,EACnF,QAAQ,SAAS,GAAG,GAAG,GAAG,EAC1B,WAAW,SAAS,MAAM,GAAG,EAAE,EAC/B,QAAQ,SAAS,MAAM,GAAG,GAAG,EAC7B,mBAAmB,SAAS,MAAM,GAAG,EAAE,EACvC,WAAW,SAAS,MAAM,GAAG,iBAAiB,CAAC,OAAO,CAAC,CACvD,SAAQ,kBAAkB,CAAC,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,mBAAmB,CAAC;IAChF,UAAU,EAAE,wBAAwB,CAAC,WAAW,CAAC,CAAC;gBAEtC,IAAI,EAAE;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,UAAU,EAAE,wBAAwB,CAAC,WAAW,CAAC,CAAC;QAClD,WAAW,EAAE,OAAO,CAAC;KACtB;IAMD,2EAA2E;IACrE,MAAM,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;KAAE;IAiBvD,sFAAsF;IAChF,WAAW,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;KAAE;CAY7D"}

package/dist/esm/search/core/controllers/abstract.js

@@ -0,0 +1,37 @@
+import { BaseRestController } from '@venizia/ignis-kernel';
+import { HTTP } from '@venizia/ignis-helpers/common';
+/** Base tier of a generated search controller: the repository handle plus the search / multi-search verbs; SearchControllerFactory returns a thin subclass that only builds route configs and wires them. */
+export class AbstractSearchController extends BaseRestController {
+    constructor(opts) {
+        super({ scope: opts.scope, path: opts.path, isStrict: opts.isStrict });
+        this.repository = opts.repository;
+        this.definitions = opts.definitions;
+    }
+    /** POST /search - single-collection keyword/semantic/hybrid/raw search. */
+    async search(opts) {
+        const { context } = opts;
+        const input = context.req.valid('json');
+        const rs = await this.measure({
+            scope: 'search',
+            args: input,
+            task: async () => {
+                // `isFoundExact` travels to the caller so an engine whose `found` is an estimate never looks exhaustive across the HTTP boundary.
+                const { found, isFoundExact, hits } = await this.repository.search(input);
+                return { found, isFoundExact, hits: hits ?? [] };
+            },
+        });
+        return context.json(rs, HTTP.ResultCodes.RS_2.Ok);
+    }
+    /** POST /multi-search - cross-collection search, forwarded verbatim to the engine. */
+    async multiSearch(opts) {
+        const { context } = opts;
+        const input = context.req.valid('json');
+        const rs = await this.measure({
+            scope: 'multiSearch',
+            args: input,
+            task: () => this.repository.multiSearch(input),
+        });
+        return context.json(rs, HTTP.ResultCodes.RS_2.Ok);
+    }
+}
+//# sourceMappingURL=abstract.js.map

package/dist/esm/search/core/controllers/abstract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract.js","sourceRoot":"","sources":["../../../../../src/search/core/controllers/abstract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAI3D,OAAO,EAAE,IAAI,EAAE,MAAM,+BAA+B,CAAC;AAKrD,6MAA6M;AAC7M,MAAM,OAAgB,wBAOpB,SAAQ,kBAAwE;IAGhF,YAAY,IAMX;QACC,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QACvE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QAClC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;IACtC,CAAC;IAED,2EAA2E;IAC3E,KAAK,CAAC,MAAM,CAAC,IAA0C;QACrD,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;QACzB,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAe,MAAM,CAAC,CAAC;QAEtD,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC;YAC5B,KAAK,EAAE,QAAQ;YACf,IAAI,EAAE,KAAK;YACX,IAAI,EAAE,KAAK,IAAI,EAAE;gBACf,kIAAkI;gBAClI,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAC1E,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,IAAI,EAAE,EAAE,CAAC;YACnD,CAAC;SACF,CAAC,CAAC;QAEH,OAAO,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACpD,CAAC;IAED,sFAAsF;IACtF,KAAK,CAAC,WAAW,CAAC,IAA0C;QAC1D,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;QACzB,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAoB,MAAM,CAAC,CAAC;QAE3D,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC;YAC5B,KAAK,EAAE,aAAa;YACpB,IAAI,EAAE,KAAK;YACX,IAAI,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,KAAK,CAAC;SAC/C,CAAC,CAAC;QAEH,OAAO,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACpD,CAAC;CACF"}

package/dist/esm/search/core/controllers/definition.d.ts

@@ -0,0 +1,263 @@
+import type { TAuthMode, TAuthStrategy } from '@venizia/ignis-kernel';
+import type { IAuthorizationSpec } from '@venizia/ignis-kernel';
+import { z } from '@hono/zod-openapi';
+export declare const defineSearchRouteConfigs: (opts: {
+    selectSchema: z.ZodTypeAny;
+    authenticate?: {
+        strategies?: TAuthStrategy[];
+        mode?: TAuthMode;
+    };
+    authorize?: IAuthorizationSpec | IAuthorizationSpec[];
+}) => {
+    readonly SEARCH: {
+        readonly method: "post";
+        readonly path: "/search";
+        readonly description: "Single-collection search (keyword, semantic, hybrid, or raw passthrough)";
+        readonly authenticate: {
+            strategies?: TAuthStrategy[];
+            mode?: TAuthMode;
+        };
+        readonly authorize: IAuthorizationSpec<import("hono").Env, string, string> | IAuthorizationSpec<import("hono").Env, string, string>[] | undefined;
+        readonly request: {
+            readonly body: {
+                description: string;
+                content: {
+                    'application/json': {
+                        schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            facetBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            facetQuery: z.ZodOptional<z.ZodString>;
+                            maxFacetValues: z.ZodOptional<z.ZodNumber>;
+                            highlightFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            highlightFullFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            highlightStartTag: z.ZodOptional<z.ZodString>;
+                            highlightEndTag: z.ZodOptional<z.ZodString>;
+                            snippetThreshold: z.ZodOptional<z.ZodNumber>;
+                            groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            groupLimit: z.ZodOptional<z.ZodNumber>;
+                            groupMissingValues: z.ZodOptional<z.ZodBoolean>;
+                            queryByWeights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                            engineParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                            mode: z.ZodLiteral<"keyword">;
+                            query: z.ZodOptional<z.ZodString>;
+                            queryBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            filter: z.ZodOptional<z.ZodObject<{
+                                where: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<any, string>>, z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>]>>;
+                                fields: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodArray<z.ZodString>]>>;
+                                order: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                                limit: z.ZodOptional<z.ZodNumber>;
+                                offset: z.ZodOptional<z.ZodNumber>;
+                                skip: z.ZodOptional<z.ZodNumber>;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            distanceThreshold: z.ZodOptional<z.ZodNumber>;
+                            ef: z.ZodOptional<z.ZodNumber>;
+                            facetBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            facetQuery: z.ZodOptional<z.ZodString>;
+                            maxFacetValues: z.ZodOptional<z.ZodNumber>;
+                            highlightFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            highlightFullFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            highlightStartTag: z.ZodOptional<z.ZodString>;
+                            highlightEndTag: z.ZodOptional<z.ZodString>;
+                            snippetThreshold: z.ZodOptional<z.ZodNumber>;
+                            groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            groupLimit: z.ZodOptional<z.ZodNumber>;
+                            groupMissingValues: z.ZodOptional<z.ZodBoolean>;
+                            queryByWeights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                            engineParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                            mode: z.ZodLiteral<"semantic">;
+                            vectorField: z.ZodString;
+                            nearVector: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                            queryText: z.ZodOptional<z.ZodString>;
+                            k: z.ZodOptional<z.ZodNumber>;
+                            filter: z.ZodOptional<z.ZodObject<{
+                                where: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<any, string>>, z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>]>>;
+                                fields: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodArray<z.ZodString>]>>;
+                                order: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                                limit: z.ZodOptional<z.ZodNumber>;
+                                offset: z.ZodOptional<z.ZodNumber>;
+                                skip: z.ZodOptional<z.ZodNumber>;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            distanceThreshold: z.ZodOptional<z.ZodNumber>;
+                            ef: z.ZodOptional<z.ZodNumber>;
+                            facetBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            facetQuery: z.ZodOptional<z.ZodString>;
+                            maxFacetValues: z.ZodOptional<z.ZodNumber>;
+                            highlightFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            highlightFullFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            highlightStartTag: z.ZodOptional<z.ZodString>;
+                            highlightEndTag: z.ZodOptional<z.ZodString>;
+                            snippetThreshold: z.ZodOptional<z.ZodNumber>;
+                            groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            groupLimit: z.ZodOptional<z.ZodNumber>;
+                            groupMissingValues: z.ZodOptional<z.ZodBoolean>;
+                            queryByWeights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                            engineParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                            mode: z.ZodLiteral<"hybrid">;
+                            query: z.ZodString;
+                            queryBy: z.ZodArray<z.ZodString>;
+                            vectorField: z.ZodString;
+                            nearVector: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                            alpha: z.ZodOptional<z.ZodNumber>;
+                            k: z.ZodOptional<z.ZodNumber>;
+                            filter: z.ZodOptional<z.ZodObject<{
+                                where: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<any, string>>, z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>]>>;
+                                fields: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodArray<z.ZodString>]>>;
+                                order: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                                limit: z.ZodOptional<z.ZodNumber>;
+                                offset: z.ZodOptional<z.ZodNumber>;
+                                skip: z.ZodOptional<z.ZodNumber>;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            mode: z.ZodLiteral<"raw">;
+                            params: z.ZodRecord<z.ZodString, z.ZodAny>;
+                        }, z.core.$strip>], "mode">;
+                    };
+                };
+                required: boolean | undefined;
+            };
+        };
+        readonly responses: {
+            200: {
+                description: string;
+                content: {
+                    'application/json': {
+                        schema: z.ZodObject<{
+                            found: z.ZodNumber;
+                            isFoundExact: z.ZodBoolean;
+                            hits: z.ZodArray<z.ZodObject<{
+                                document: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>;
+                    };
+                };
+                required: boolean | undefined;
+            } | {
+                headers: never;
+                description: string;
+                content: {
+                    'application/json': {
+                        schema: z.ZodObject<{
+                            found: z.ZodNumber;
+                            isFoundExact: z.ZodBoolean;
+                            hits: z.ZodArray<z.ZodObject<{
+                                document: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>;
+                    };
+                };
+                required: boolean | undefined;
+            };
+            "4xx | 5xx": {
+                description: string;
+                content: {
+                    "application/json": {
+                        schema: z.ZodObject<{
+                            statusCode: z.ZodOptional<z.ZodNumber>;
+                            message: z.ZodString;
+                            normalized: z.ZodOptional<z.ZodObject<{
+                                text: z.ZodString;
+                                code: z.ZodString;
+                                args: z.ZodRecord<z.ZodString, z.ZodAny>;
+                            }, z.core.$strip>>;
+                            extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                            requestId: z.ZodOptional<z.ZodString>;
+                            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                        }, z.core.$strip>;
+                    };
+                };
+                required: boolean | undefined;
+            };
+        };
+    };
+    readonly MULTI_SEARCH: {
+        readonly method: "post";
+        readonly path: "/multi-search";
+        readonly description: "Cross-collection search, forwarded verbatim to the search engine";
+        readonly authenticate: {
+            strategies?: TAuthStrategy[];
+            mode?: TAuthMode;
+        };
+        readonly authorize: IAuthorizationSpec<import("hono").Env, string, string> | IAuthorizationSpec<import("hono").Env, string, string>[] | undefined;
+        readonly request: {
+            readonly body: {
+                description: string;
+                content: {
+                    'application/json': {
+                        schema: z.ZodObject<{
+                            searches: z.ZodArray<z.ZodObject<{
+                                facetBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                                facetQuery: z.ZodOptional<z.ZodString>;
+                                maxFacetValues: z.ZodOptional<z.ZodNumber>;
+                                highlightFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                                highlightFullFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                                highlightStartTag: z.ZodOptional<z.ZodString>;
+                                highlightEndTag: z.ZodOptional<z.ZodString>;
+                                snippetThreshold: z.ZodOptional<z.ZodNumber>;
+                                groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                                groupLimit: z.ZodOptional<z.ZodNumber>;
+                                groupMissingValues: z.ZodOptional<z.ZodBoolean>;
+                                queryByWeights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                                engineParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                                collection: z.ZodString;
+                                query: z.ZodOptional<z.ZodString>;
+                                queryBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                                filterBy: z.ZodOptional<z.ZodString>;
+                                sortBy: z.ZodOptional<z.ZodString>;
+                                page: z.ZodOptional<z.ZodNumber>;
+                                perPage: z.ZodOptional<z.ZodNumber>;
+                                offset: z.ZodOptional<z.ZodNumber>;
+                                includeFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                                excludeFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                                vectorQuery: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strip>>;
+                            union: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>;
+                    };
+                };
+                required: boolean | undefined;
+            };
+        };
+        readonly responses: {
+            200: {
+                description: string;
+                content: {
+                    'application/json': {
+                        schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    };
+                };
+                required: boolean | undefined;
+            } | {
+                headers: never;
+                description: string;
+                content: {
+                    'application/json': {
+                        schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    };
+                };
+                required: boolean | undefined;
+            };
+            "4xx | 5xx": {
+                description: string;
+                content: {
+                    "application/json": {
+                        schema: z.ZodObject<{
+                            statusCode: z.ZodOptional<z.ZodNumber>;
+                            message: z.ZodString;
+                            normalized: z.ZodOptional<z.ZodObject<{
+                                text: z.ZodString;
+                                code: z.ZodString;
+                                args: z.ZodRecord<z.ZodString, z.ZodAny>;
+                            }, z.core.$strip>>;
+                            extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                            requestId: z.ZodOptional<z.ZodString>;
+                            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                        }, z.core.$strip>;
+                    };
+                };
+                required: boolean | undefined;
+            };
+        };
+    };
+};
+//# sourceMappingURL=definition.d.ts.map

package/dist/esm/search/core/controllers/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../../../src/search/core/controllers/definition.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAItC,eAAO,MAAM,wBAAwB,GAAI,MAAM;IAC7C,YAAY,EAAE,CAAC,CAAC,UAAU,CAAC;IAC3B,YAAY,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,SAAS,CAAA;KAAE,CAAC;IAClE,SAAS,CAAC,EAAE,kBAAkB,GAAG,kBAAkB,EAAE,CAAC;CACvD;;;;;;yBAF+B,aAAa,EAAE;mBAAS,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAAjC,aAAa,EAAE;mBAAS,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDhE,CAAC"}

package/dist/esm/search/core/controllers/definition.js

@@ -0,0 +1,53 @@
+import { jsonContent, jsonResponse } from '@venizia/ignis-kernel';
+import { z } from '@hono/zod-openapi';
+import { HTTP } from '@venizia/ignis-helpers/common';
+import { MultiSearchInputSchema, SearchInputSchema } from '../../../search/core/repositories/common/index.js';
+export const defineSearchRouteConfigs = (opts) => {
+    const { selectSchema, authenticate, authorize } = opts;
+    const searchResponseSchema = z.object({
+        found: z.number(),
+        isFoundExact: z
+            .boolean()
+            .openapi({ description: 'False when the engine reports `found` as an estimate.' }),
+        hits: z.array(z.object({ document: selectSchema })),
+    });
+    const multiSearchResponseSchema = z.record(z.string(), z.unknown());
+    const resolvedAuthenticate = authenticate ?? {};
+    return {
+        SEARCH: {
+            method: HTTP.Methods.POST,
+            path: '/search',
+            description: 'Single-collection search (keyword, semantic, hybrid, or raw passthrough)',
+            authenticate: resolvedAuthenticate,
+            authorize,
+            request: {
+                body: jsonContent({
+                    description: 'Search input, discriminated by mode',
+                    schema: SearchInputSchema,
+                }),
+            },
+            responses: jsonResponse({
+                description: 'Search results',
+                schema: searchResponseSchema,
+            }),
+        },
+        MULTI_SEARCH: {
+            method: HTTP.Methods.POST,
+            path: '/multi-search',
+            description: 'Cross-collection search, forwarded verbatim to the search engine',
+            authenticate: resolvedAuthenticate,
+            authorize,
+            request: {
+                body: jsonContent({
+                    description: 'Multi-search input - one or more per-collection native search params',
+                    schema: MultiSearchInputSchema,
+                }),
+            },
+            responses: jsonResponse({
+                description: 'Federated (or, when union is true, merged) search results',
+                schema: multiSearchResponseSchema,
+            }),
+        },
+    };
+};
+//# sourceMappingURL=definition.js.map

package/dist/esm/search/core/controllers/definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../../../../src/search/core/controllers/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAGlE,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,+BAA+B,CAAC;AACrD,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAE9F,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,IAIxC,EAAE,EAAE;IACH,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IAEvD,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;QACpC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;QACjB,YAAY,EAAE,CAAC;aACZ,OAAO,EAAE;aACT,OAAO,CAAC,EAAE,WAAW,EAAE,uDAAuD,EAAE,CAAC;QACpF,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,CAAC,CAAC;KACpD,CAAC,CAAC;IAEH,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;IAEpE,MAAM,oBAAoB,GAAG,YAAY,IAAI,EAAE,CAAC;IAEhD,OAAO;QACL,MAAM,EAAE;YACN,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;YACzB,IAAI,EAAE,SAAS;YACf,WAAW,EAAE,0EAA0E;YACvF,YAAY,EAAE,oBAAoB;YAClC,SAAS;YACT,OAAO,EAAE;gBACP,IAAI,EAAE,WAAW,CAAC;oBAChB,WAAW,EAAE,qCAAqC;oBAClD,MAAM,EAAE,iBAAiB;iBAC1B,CAAC;aACH;YACD,SAAS,EAAE,YAAY,CAAC;gBACtB,WAAW,EAAE,gBAAgB;gBAC7B,MAAM,EAAE,oBAAoB;aAC7B,CAAC;SACH;QAED,YAAY,EAAE;YACZ,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;YACzB,IAAI,EAAE,eAAe;YACrB,WAAW,EAAE,kEAAkE;YAC/E,YAAY,EAAE,oBAAoB;YAClC,SAAS;YACT,OAAO,EAAE;gBACP,IAAI,EAAE,WAAW,CAAC;oBAChB,WAAW,EAAE,sEAAsE;oBACnF,MAAM,EAAE,sBAAsB;iBAC/B,CAAC;aACH;YACD,SAAS,EAAE,YAAY,CAAC;gBACtB,WAAW,EAAE,2DAA2D;gBACxE,MAAM,EAAE,yBAAyB;aAClC,CAAC;SACH;KACO,CAAC;AACb,CAAC,CAAC"}

package/dist/esm/search/core/controllers/factory.d.ts

@@ -0,0 +1,113 @@
+import type { TEntityDataObject } from '@venizia/ignis-kernel';
+import type { AbstractEntity } from '@venizia/ignis-kernel';
+import type { TAuthMode, TAuthStrategy } from '@venizia/ignis-kernel';
+import type { IAuthorizationSpec } from '@venizia/ignis-kernel';
+import type { TAnyObjectSchema } from '@venizia/ignis-kernel';
+import type { TClass, TResolver, ValueOrPromise } from '@venizia/ignis-helpers/common';
+import { BaseHelper } from '@venizia/ignis-helpers/core';
+import type { Env, Schema } from 'hono';
+import type { ReadableSearchRepository } from '../repositories/core/readable.js';
+/** Per-route enable/disable switches for the generated search controller. */
+export interface ISearchCustomizableRoutes {
+    search?: {
+        enabled?: boolean;
+    };
+    multiSearch?: {
+        enabled?: boolean;
+    };
+}
+/** Configuration options for creating a search controller via SearchControllerFactory.defineSearchController. */
+export interface ISearchControllerOptions<TEntity extends AbstractEntity<TAnyObjectSchema> = AbstractEntity<TAnyObjectSchema>> {
+    /** Entity class or resolver returning it; its SELECT schema drives the `hits[].document` shape in the generated route's response. */
+    entity: TClass<TEntity> | TResolver<TClass<TEntity>>;
+    repository: {
+        name: string;
+    };
+    controller: {
+        name: string;
+        basePath: string;
+        isStrict?: boolean;
+    };
+    /** Authentication config applied to both generated routes. */
+    authenticate?: {
+        strategies?: TAuthStrategy[];
+        mode?: TAuthMode;
+    };
+    /** Authorization config applied to both generated routes. */
+    authorize?: IAuthorizationSpec | IAuthorizationSpec[];
+    /** Per-route enable/disable configuration. */
+    routes?: ISearchCustomizableRoutes;
+}
+/** Factory for generating turnkey search controllers (single-collection + cross-collection) from entity definitions. */
+export declare class SearchControllerFactory extends BaseHelper {
+    constructor();
+    /** Creates a search controller with two endpoints: `POST {basePath}/search` via `repository.search()`, and `POST {basePath}/multi-search` via `repository.dataSource.multiSearch()`. */
+    static defineSearchController<TEntity extends AbstractEntity<TAnyObjectSchema> = AbstractEntity<TAnyObjectSchema>, RouteEnv extends Env = Env, RouteSchema extends Schema = {}, BasePath extends string = '/', ConfigurableOptions extends object = {}, TDataObject extends object = TEntityDataObject<TEntity>>(defOpts: ISearchControllerOptions<TEntity>): {
+        new (repository: ReadableSearchRepository<TDataObject>): {
+            /** Registers the search + multiSearch route handlers, honoring per-route enable flags. */
+            binding(): ValueOrPromise<void>;
+            repository: ReadableSearchRepository<TDataObject, import("../index.js").AbstractSearchDataSource<{}>>;
+            search(opts: {
+                context: import("@venizia/ignis-kernel").TRouteContext<RouteEnv>;
+            }): Promise<import("@venizia/ignis-kernel").TJsonResponse<unknown, 200>>;
+            multiSearch(opts: {
+                context: import("@venizia/ignis-kernel").TRouteContext<RouteEnv>;
+            }): Promise<import("@venizia/ignis-kernel").TJsonResponse<unknown, 200>>;
+            measure<R>(opts: {
+                scope: string;
+                args: unknown;
+                task: () => Promise<R>;
+            }): Promise<any>;
+            toHonoHandler<ResponseType = unknown>(opts: {
+                handler: import("@venizia/ignis-kernel").TRouteHandler<ResponseType, RouteEnv>;
+            }): import("hono").Handler<RouteEnv, string, import("hono").Input, (Response | Promise<Response>) | (import("@hono/zod-openapi").RouteConfigToTypedResponse<import("@hono/zod-openapi").RouteConfig> | Promise<import("@hono/zod-openapi").RouteConfigToTypedResponse<import("@hono/zod-openapi").RouteConfig>>)>;
+            bindRoute<RouteConfig extends import("@venizia/ignis-kernel").IAuthRouteConfig>(opts: {
+                configs: RouteConfig;
+            }): import("@venizia/ignis-kernel").IBindRouteOptions<RouteConfig, RouteEnv, RouteSchema, BasePath>;
+            defineRoute<RouteConfig extends import("@venizia/ignis-kernel").IAuthRouteConfig, ResponseType = unknown>(opts: {
+                configs: RouteConfig;
+                handler: import("@venizia/ignis-kernel").TRouteHandler<ResponseType, RouteEnv>;
+                hook?: import("@hono/zod-openapi").Hook<any, RouteEnv, string, any> | undefined;
+            }): import("@venizia/ignis-kernel").IDefineRouteOptions<RouteConfig, RouteEnv, RouteSchema, BasePath>;
+            defineJSXRoute<RouteConfig extends import("@venizia/ignis-kernel").IAuthRouteConfig, ResponseType = unknown>(opts: {
+                configs: RouteConfig;
+                handler: import("@venizia/ignis-kernel").TRouteHandler<ResponseType, RouteEnv>;
+                hook?: import("@hono/zod-openapi").Hook<any, RouteEnv, string, any> | undefined;
+            }): import("@venizia/ignis-kernel").IDefineRouteOptions<RouteConfig, RouteEnv, RouteSchema, BasePath>;
+            isConfigured: boolean;
+            router: import("@hono/zod-openapi").OpenAPIHono<RouteEnv, RouteSchema, BasePath>;
+            path: string;
+            definitions: Record<string, import("@venizia/ignis-kernel").IAuthRouteConfig>;
+            getRouter(): import("@hono/zod-openapi").OpenAPIHono<RouteEnv, RouteSchema, BasePath>;
+            registerRoutesFromRegistry(opts?: {
+                paths?: "static" | "param" | "all";
+            }): void;
+            configure(opts?: ConfigurableOptions | undefined): Promise<import("@hono/zod-openapi").OpenAPIHono<RouteEnv, RouteSchema, BasePath>>;
+            buildRouteMiddlewares<RouteConfig extends import("@venizia/ignis-kernel").IAuthRouteConfig>(opts: {
+                configs: RouteConfig;
+            }): {
+                restConfig: Omit<RouteConfig, "authenticate" | "authorize">;
+                security: {
+                    [x: string]: never[];
+                }[];
+                mws: import("hono").MiddlewareHandler<Env>[];
+            };
+            getRouteConfigs<RouteConfig extends import("@venizia/ignis-kernel").IAuthRouteConfig>(opts: {
+                configs: RouteConfig;
+            }): RouteConfig & {
+                getRoutingPath(): RouteConfig["path"] extends infer T ? T extends RouteConfig["path"] ? T extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head_1}/{${infer Param_1}}${infer Tail_1}` ? `${Head_1}/:${Param_1}${Tail_1 extends `${infer Head_2}/{${infer Param_2}}${infer Tail_2}` ? `${Head_2}/:${Param_2}${Tail_2 extends `${infer Head_3}/{${infer Param_3}}${infer Tail_3}` ? `${Head_3}/:${Param_3}${Tail_3 extends `${infer Head_4}/{${infer Param_4}}${infer Tail_4}` ? `${Head_4}/:${Param_4}${Tail_4 extends `${infer Head_5}/{${infer Param_5}}${infer Tail_5}` ? `${Head_5}/:${Param_5}${Tail_5 extends `${infer Head_6}/{${infer Param_6}}${infer Tail_6}` ? `${Head_6}/:${Param_6}${Tail_6 extends `${infer Head_7}/{${infer Param_7}}${infer Tail_7}` ? `${Head_7}/:${Param_7}${Tail_7 extends `${infer Head_8}/{${infer Param_8}}${infer Tail_8}` ? `${Head_8}/:${Param_8}${Tail_8 extends `${infer Head_9}/{${infer Param_9}}${infer Tail_9}` ? `${Head_9}/:${Param_9}${Tail_9 extends `${infer Head_10}/{${infer Param_10}}${infer Tail_10}` ? `${Head_10}/:${Param_10}${any}` : Tail_9}` : Tail_8}` : Tail_7}` : Tail_6}` : Tail_5}` : Tail_4}` : Tail_3}` : Tail_2}` : Tail_1}` : Tail}` : T : never : never;
+            };
+            getJSXRouteConfigs<RouteConfig extends import("@venizia/ignis-kernel").IAuthRouteConfig>(opts: {
+                configs: RouteConfig;
+            }): RouteConfig & {
+                getRoutingPath(): RouteConfig["path"] extends infer T ? T extends RouteConfig["path"] ? T extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head_1}/{${infer Param_1}}${infer Tail_1}` ? `${Head_1}/:${Param_1}${Tail_1 extends `${infer Head_2}/{${infer Param_2}}${infer Tail_2}` ? `${Head_2}/:${Param_2}${Tail_2 extends `${infer Head_3}/{${infer Param_3}}${infer Tail_3}` ? `${Head_3}/:${Param_3}${Tail_3 extends `${infer Head_4}/{${infer Param_4}}${infer Tail_4}` ? `${Head_4}/:${Param_4}${Tail_4 extends `${infer Head_5}/{${infer Param_5}}${infer Tail_5}` ? `${Head_5}/:${Param_5}${Tail_5 extends `${infer Head_6}/{${infer Param_6}}${infer Tail_6}` ? `${Head_6}/:${Param_6}${Tail_6 extends `${infer Head_7}/{${infer Param_7}}${infer Tail_7}` ? `${Head_7}/:${Param_7}${Tail_7 extends `${infer Head_8}/{${infer Param_8}}${infer Tail_8}` ? `${Head_8}/:${Param_8}${Tail_8 extends `${infer Head_9}/{${infer Param_9}}${infer Tail_9}` ? `${Head_9}/:${Param_9}${Tail_9 extends `${infer Head_10}/{${infer Param_10}}${infer Tail_10}` ? `${Head_10}/:${Param_10}${any}` : Tail_9}` : Tail_8}` : Tail_7}` : Tail_6}` : Tail_5}` : Tail_4}` : Tail_3}` : Tail_2}` : Tail_1}` : Tail}` : T : never : never;
+            };
+            scope: string;
+            identifier: string;
+            logger: import("@venizia/ignis-helpers").ILogger;
+            getIdentifier(): string;
+            getLogger(): import("@venizia/ignis-helpers").ILogger;
+        };
+    };
+}
+//# sourceMappingURL=factory.d.ts.map

package/dist/esm/search/core/controllers/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../../src/search/core/controllers/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACvF,OAAO,EAAE,UAAU,EAAY,MAAM,6BAA6B,CAAC;AAEnE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACxC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAI9E,6EAA6E;AAC7E,MAAM,WAAW,yBAAyB;IACxC,MAAM,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAC/B,WAAW,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CACrC;AAED,iHAAiH;AACjH,MAAM,WAAW,wBAAwB,CACvC,OAAO,SAAS,cAAc,CAAC,gBAAgB,CAAC,GAAG,cAAc,CAAC,gBAAgB,CAAC;IAEnF,qIAAqI;IACrI,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IAErD,UAAU,EAAE;QACV,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IAEF,UAAU,EAAE;QACV,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB,CAAC;IAEF,8DAA8D;IAC9D,YAAY,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,SAAS,CAAA;KAAE,CAAC;IAElE,6DAA6D;IAC7D,SAAS,CAAC,EAAE,kBAAkB,GAAG,kBAAkB,EAAE,CAAC;IAEtD,8CAA8C;IAC9C,MAAM,CAAC,EAAE,yBAAyB,CAAC;CACpC;AAED,wHAAwH;AACxH,qBAAa,uBAAwB,SAAQ,UAAU;;IAKrD,wLAAwL;IACxL,MAAM,CAAC,sBAAsB,CAC3B,OAAO,SAAS,cAAc,CAAC,gBAAgB,CAAC,GAAG,cAAc,CAAC,gBAAgB,CAAC,EACnF,QAAQ,SAAS,GAAG,GAAG,GAAG,EAC1B,WAAW,SAAS,MAAM,GAAG,EAAE,EAC/B,QAAQ,SAAS,MAAM,GAAG,GAAG,EAC7B,mBAAmB,SAAS,MAAM,GAAG,EAAE,EACvC,WAAW,SAAS,MAAM,GAAG,iBAAiB,CAAC,OAAO,CAAC,EACvD,OAAO,EAAE,wBAAwB,CAAC,OAAO,CAAC;yBAwBhB,wBAAwB,CAAC,WAAW,CAAC;YAU7D,0FAA0F;uBACtE,cAAc,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAvEnC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+FX"}

package/dist/esm/search/core/controllers/factory.js

@@ -0,0 +1,57 @@
+import { SchemaTypes } from '@venizia/ignis-kernel';
+import { BaseHelper, getError } from '@venizia/ignis-helpers/core';
+import { isClass } from '@venizia/ignis-inversion';
+import { AbstractSearchController } from './abstract.js';
+import { defineSearchRouteConfigs } from './definition.js';
+/** Factory for generating turnkey search controllers (single-collection + cross-collection) from entity definitions. */
+export class SearchControllerFactory extends BaseHelper {
+    constructor() {
+        super({ scope: SearchControllerFactory.name });
+    }
+    /** Creates a search controller with two endpoints: `POST {basePath}/search` via `repository.search()`, and `POST {basePath}/multi-search` via `repository.dataSource.multiSearch()`. */
+    static defineSearchController(defOpts) {
+        const { controller, entity, authenticate, authorize, routes } = defOpts;
+        const { name, basePath = 'unknown_path', isStrict = true } = controller;
+        if (!basePath || basePath === 'unknown_path') {
+            throw getError({
+                message: `[defineSearchController] Invalid controller basePath | name: ${name} | basePath: ${basePath}`,
+            });
+        }
+        const entityClass = isClass(entity) ? entity : entity();
+        const entityInstance = new entityClass();
+        const selectSchema = entityInstance.getSchema({ type: SchemaTypes.SELECT });
+        const routeDefinitions = defineSearchRouteConfigs({ selectSchema, authenticate, authorize });
+        const controllerClass = class extends AbstractSearchController {
+            constructor(repository) {
+                super({
+                    scope: name,
+                    path: basePath,
+                    isStrict,
+                    repository,
+                    definitions: routeDefinitions,
+                });
+            }
+            /** Registers the search + multiSearch route handlers, honoring per-route enable flags. */
+            binding() {
+                const isEnabled = (routeKey) => {
+                    return routes?.[routeKey]?.enabled !== false;
+                };
+                if (isEnabled('search')) {
+                    this.defineRoute({
+                        configs: routeDefinitions.SEARCH,
+                        handler: async (context) => this.search({ context }),
+                    });
+                }
+                if (isEnabled('multiSearch')) {
+                    this.defineRoute({
+                        configs: routeDefinitions.MULTI_SEARCH,
+                        handler: async (context) => this.multiSearch({ context }),
+                    });
+                }
+            }
+        };
+        Object.defineProperty(controllerClass, 'name', { value: name, configurable: true });
+        return controllerClass;
+    }
+}
+//# sourceMappingURL=factory.js.map

package/dist/esm/search/core/controllers/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../../../../src/search/core/controllers/factory.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAKpD,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAGnD,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAmCxD,wHAAwH;AACxH,MAAM,OAAO,uBAAwB,SAAQ,UAAU;IACrD;QACE,KAAK,CAAC,EAAE,KAAK,EAAE,uBAAuB,CAAC,IAAI,EAAE,CAAC,CAAC;IACjD,CAAC;IAED,wLAAwL;IACxL,MAAM,CAAC,sBAAsB,CAO3B,OAA0C;QAC1C,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;QAExE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,cAAc,EAAE,QAAQ,GAAG,IAAI,EAAE,GAAG,UAAU,CAAC;QACxE,IAAI,CAAC,QAAQ,IAAI,QAAQ,KAAK,cAAc,EAAE,CAAC;YAC7C,MAAM,QAAQ,CAAC;gBACb,OAAO,EAAE,gEAAgE,IAAI,gBAAgB,QAAQ,EAAE;aACxG,CAAC,CAAC;QACL,CAAC;QAED,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;QACxD,MAAM,cAAc,GAAG,IAAI,WAAW,EAAE,CAAC;QAEzC,MAAM,YAAY,GAAG,cAAc,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC;QAC5E,MAAM,gBAAgB,GAAG,wBAAwB,CAAC,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,CAAC,CAAC;QAE7F,MAAM,eAAe,GAAG,KAAM,SAAQ,wBAOrC;YACC,YAAY,UAAiD;gBAC3D,KAAK,CAAC;oBACJ,KAAK,EAAE,IAAI;oBACX,IAAI,EAAE,QAAQ;oBACd,QAAQ;oBACR,UAAU;oBACV,WAAW,EAAE,gBAAgB;iBAC9B,CAAC,CAAC;YACL,CAAC;YAED,0FAA0F;YACjF,OAAO;gBACd,MAAM,SAAS,GAAG,CAAC,QAAyC,EAAE,EAAE;oBAC9D,OAAO,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,OAAO,KAAK,KAAK,CAAC;gBAC/C,CAAC,CAAC;gBAEF,IAAI,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC;oBACxB,IAAI,CAAC,WAAW,CAAC;wBACf,OAAO,EAAE,gBAAgB,CAAC,MAAM;wBAChC,OAAO,EAAE,KAAK,EAAC,OAAO,EAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;qBACnD,CAAC,CAAC;gBACL,CAAC;gBAED,IAAI,SAAS,CAAC,aAAa,CAAC,EAAE,CAAC;oBAC7B,IAAI,CAAC,WAAW,CAAC;wBACf,OAAO,EAAE,gBAAgB,CAAC,YAAY;wBACtC,OAAO,EAAE,KAAK,EAAC,OAAO,EAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,CAAC;qBACxD,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;SACF,CAAC;QAEF,MAAM,CAAC,cAAc,CAAC,eAAe,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC;QACpF,OAAO,eAAe,CAAC;IACzB,CAAC;CACF"}

package/dist/esm/search/core/controllers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './abstract.js';
+export * from './definition.js';
+export * from './factory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/search/core/controllers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/search/core/controllers/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC"}

package/dist/esm/search/core/controllers/index.js

@@ -0,0 +1,4 @@
+export * from './abstract.js';
+export * from './definition.js';
+export * from './factory.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/search/core/controllers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/search/core/controllers/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC"}

package/dist/esm/search/core/datasources/abstract.d.ts

@@ -0,0 +1,23 @@
+import { AbstractDataSource } from '@venizia/ignis-kernel';
+import type { ISearchConnector } from '../../../search/core/connector.js';
+import type { ISearchCollectionDefinition, TSearchSchema } from '../../../search/core/models/index.js';
+import type { ISearchQueryDialect, TMultiSearchEntry } from '../../../search/core/repositories/common/index.js';
+/** Engine contract only (connector, dialect, collection compile/ensure) - mirrors AbstractPostgresDataSource. Discovery/provisioning lives on BaseSearchDataSource. */
+export declare abstract class AbstractSearchDataSource<Settings extends object = {}> extends AbstractDataSource<Settings, TSearchSchema> {
+    abstract getConnector(): ISearchConnector;
+    abstract getQueryDialect(): ISearchQueryDialect;
+    abstract compileCollection(opts: {
+        definition: ISearchCollectionDefinition;
+    }): unknown;
+    abstract ensureCollection(opts: {
+        definition: ISearchCollectionDefinition;
+    }): Promise<void>;
+    /** Cross-collection search. Return is `unknown` because each engine's envelope differs (Typesense union, Meilisearch federation) and a concrete datasource narrows it; declared here so a datasource-generic repository can read it. */
+    abstract multiSearch(opts: {
+        searches: TMultiSearchEntry[];
+        union?: boolean;
+        commonParams?: Omit<TMultiSearchEntry, 'collection'>;
+        options?: unknown;
+    }): Promise<unknown>;
+}
+//# sourceMappingURL=abstract.d.ts.map

package/dist/esm/search/core/datasources/abstract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract.d.ts","sourceRoot":"","sources":["../../../../../src/search/core/datasources/abstract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,2BAA2B,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACvF,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAEhG,uKAAuK;AACvK,8BAAsB,wBAAwB,CAC5C,QAAQ,SAAS,MAAM,GAAG,EAAE,CAC5B,SAAQ,kBAAkB,CAAC,QAAQ,EAAE,aAAa,CAAC;IACnD,QAAQ,CAAC,YAAY,IAAI,gBAAgB;IAEzC,QAAQ,CAAC,eAAe,IAAI,mBAAmB;IAE/C,QAAQ,CAAC,iBAAiB,CAAC,IAAI,EAAE;QAAE,UAAU,EAAE,2BAA2B,CAAA;KAAE,GAAG,OAAO;IACtF,QAAQ,CAAC,gBAAgB,CAAC,IAAI,EAAE;QAAE,UAAU,EAAE,2BAA2B,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAE3F,wOAAwO;IACxO,QAAQ,CAAC,WAAW,CAAC,IAAI,EAAE;QACzB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;QAC9B,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,YAAY,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAC;QACrD,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,GAAG,OAAO,CAAC,OAAO,CAAC;CACrB"}

package/dist/esm/search/core/datasources/abstract.js

@@ -0,0 +1,5 @@
+import { AbstractDataSource } from '@venizia/ignis-kernel';
+/** Engine contract only (connector, dialect, collection compile/ensure) - mirrors AbstractPostgresDataSource. Discovery/provisioning lives on BaseSearchDataSource. */
+export class AbstractSearchDataSource extends AbstractDataSource {
+}
+//# sourceMappingURL=abstract.js.map

package/dist/esm/search/core/datasources/abstract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract.js","sourceRoot":"","sources":["../../../../../src/search/core/datasources/abstract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAK3D,uKAAuK;AACvK,MAAM,OAAgB,wBAEpB,SAAQ,kBAA2C;CAepD"}