@venizia/ignis 0.0.10-4 → 0.1.0

package/dist/connectors/search/controllers/definition.d.ts

@@ -0,0 +1,251 @@
+import type { TAuthMode, TAuthStrategy } from '../../../components/auth/authenticate/common/constants';
+import type { IAuthorizationSpec } from '../../../components/auth/authorize/common/types';
+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<{
+                            name: z.ZodOptional<z.ZodString>;
+                            statusCode: z.ZodOptional<z.ZodNumber>;
+                            messageCode: z.ZodOptional<z.ZodString>;
+                            message: z.ZodString;
+                        }, z.core.$catchall<z.ZodAny>>;
+                    };
+                };
+                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<{
+                            name: z.ZodOptional<z.ZodString>;
+                            statusCode: z.ZodOptional<z.ZodNumber>;
+                            messageCode: z.ZodOptional<z.ZodString>;
+                            message: z.ZodString;
+                        }, z.core.$catchall<z.ZodAny>>;
+                    };
+                };
+                required: boolean | undefined;
+            };
+        };
+    };
+};
+//# sourceMappingURL=definition.d.ts.map

package/dist/connectors/search/controllers/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../../src/connectors/search/controllers/definition.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AAChG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AACnF,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/connectors/search/controllers/definition.js

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

package/dist/connectors/search/controllers/definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../../../src/connectors/search/controllers/definition.ts"],"names":[],"mappings":";;;AAAA,0CAA0D;AAG1D,mDAAsC;AACtC,0DAA8C;AAC9C,oEAAoG;AAE7F,MAAM,wBAAwB,GAAG,CAAC,IAIxC,EAAE,EAAE;IACH,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IAEvD,MAAM,oBAAoB,GAAG,eAAC,CAAC,MAAM,CAAC;QACpC,KAAK,EAAE,eAAC,CAAC,MAAM,EAAE;QACjB,YAAY,EAAE,eAAC;aACZ,OAAO,EAAE;aACT,OAAO,CAAC,EAAE,WAAW,EAAE,uDAAuD,EAAE,CAAC;QACpF,IAAI,EAAE,eAAC,CAAC,KAAK,CAAC,eAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,CAAC,CAAC;KACpD,CAAC,CAAC;IAEH,MAAM,yBAAyB,GAAG,eAAC,CAAC,MAAM,CAAC,eAAC,CAAC,MAAM,EAAE,EAAE,eAAC,CAAC,OAAO,EAAE,CAAC,CAAC;IAEpE,MAAM,oBAAoB,GAAG,YAAY,IAAI,EAAE,CAAC;IAEhD,OAAO;QACL,MAAM,EAAE;YACN,MAAM,EAAE,oBAAI,CAAC,OAAO,CAAC,IAAI;YACzB,IAAI,EAAE,SAAS;YACf,WAAW,EAAE,0EAA0E;YACvF,YAAY,EAAE,oBAAoB;YAClC,SAAS;YACT,OAAO,EAAE;gBACP,IAAI,EAAE,IAAA,oBAAW,EAAC;oBAChB,WAAW,EAAE,qCAAqC;oBAClD,MAAM,EAAE,0BAAiB;iBAC1B,CAAC;aACH;YACD,SAAS,EAAE,IAAA,qBAAY,EAAC;gBACtB,WAAW,EAAE,gBAAgB;gBAC7B,MAAM,EAAE,oBAAoB;aAC7B,CAAC;SACH;QAED,YAAY,EAAE;YACZ,MAAM,EAAE,oBAAI,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,IAAA,oBAAW,EAAC;oBAChB,WAAW,EAAE,sEAAsE;oBACnF,MAAM,EAAE,+BAAsB;iBAC/B,CAAC;aACH;YACD,SAAS,EAAE,IAAA,qBAAY,EAAC;gBACtB,WAAW,EAAE,2DAA2D;gBACxE,MAAM,EAAE,yBAAyB;aAClC,CAAC;SACH;KACO,CAAC;AACb,CAAC,CAAC;AAxDW,QAAA,wBAAwB,4BAwDnC"}

package/dist/connectors/search/controllers/factory.d.ts

@@ -0,0 +1,117 @@
+import type { TEntityDataObject } from '../../../base/controllers';
+import type { AbstractEntity } from '../../../base/models';
+import type { TAuthMode, TAuthStrategy } from '../../../components/auth/authenticate/common/constants';
+import type { IAuthorizationSpec } from '../../../components/auth/authorize/common/types';
+import type { TAnyObjectSchema } from '../../../utilities/schema.utility';
+import type { TClass, TResolver, ValueOrPromise } from '@venizia/ignis-helpers';
+import { BaseHelper } from '@venizia/ignis-helpers';
+import type { Env, Schema } from 'hono';
+import type { ReadableSearchRepository } from '../repositories/core/readable';
+/** 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 function returning the entity class. Its SELECT schema drives the
+     * `hits[].document` shape in the generated search 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 generated endpoints:
+     * 1. `POST {basePath}/search` (single-collection, via `repository.search()`)
+     * 2. `POST {basePath}/multi-search` (cross-collection, 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("..").AbstractSearchDataSource<{}>>;
+            search(opts: {
+                context: import("../../../base/controllers").TRouteContext<RouteEnv>;
+            }): Promise<import("../../../base/controllers").TJsonResponse<unknown, 200>>;
+            multiSearch(opts: {
+                context: import("../../../base/controllers").TRouteContext<RouteEnv>;
+            }): Promise<import("../../../base/controllers").TJsonResponse<unknown, 200>>;
+            measure<R>(opts: {
+                scope: string;
+                args: unknown;
+                task: () => Promise<R>;
+            }): Promise<any>;
+            toHonoHandler<ResponseType = unknown>(opts: {
+                handler: import("../../../base/controllers").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("../../../base/controllers").IAuthRouteConfig>(opts: {
+                configs: RouteConfig;
+            }): import("../../../base/controllers").IBindRouteOptions<RouteConfig, RouteEnv, RouteSchema, BasePath>;
+            defineRoute<RouteConfig extends import("../../../base/controllers").IAuthRouteConfig, ResponseType = unknown>(opts: {
+                configs: RouteConfig;
+                handler: import("../../../base/controllers").TRouteHandler<ResponseType, RouteEnv>;
+                hook?: import("@hono/zod-openapi").Hook<any, RouteEnv, string, any> | undefined;
+            }): import("../../../base/controllers").IDefineRouteOptions<RouteConfig, RouteEnv, RouteSchema, BasePath>;
+            defineJSXRoute<RouteConfig extends import("../../../base/controllers").IAuthRouteConfig, ResponseType = unknown>(opts: {
+                configs: RouteConfig;
+                handler: import("../../../base/controllers").TRouteHandler<ResponseType, RouteEnv>;
+                hook?: import("@hono/zod-openapi").Hook<any, RouteEnv, string, any> | undefined;
+            }): import("../../../base/controllers").IDefineRouteOptions<RouteConfig, RouteEnv, RouteSchema, BasePath>;
+            isConfigured: boolean;
+            router: import("@hono/zod-openapi").OpenAPIHono<RouteEnv, RouteSchema, BasePath>;
+            path: string;
+            definitions: Record<string, import("../../../base/controllers").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("../../../base/controllers").IAuthRouteConfig>(opts: {
+                configs: RouteConfig;
+            }): {
+                restConfig: Omit<RouteConfig, "authenticate" | "authorize">;
+                security: {
+                    [x: string]: never[];
+                }[];
+                mws: import("hono").MiddlewareHandler<Env>[];
+            };
+            getRouteConfigs<RouteConfig extends import("../../../base/controllers").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}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${/*elided*/ any}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : T : never : never;
+            };
+            getJSXRouteConfigs<RouteConfig extends import("../../../base/controllers").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}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${/*elided*/ any}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : T : never : never;
+            };
+            scope: string;
+            identifier: string;
+            logger: import("@venizia/ignis-helpers").Logger;
+            getIdentifier(): string;
+            getLogger(): import("@venizia/ignis-helpers").Logger;
+        };
+    };
+}
+//# sourceMappingURL=factory.d.ts.map

package/dist/connectors/search/controllers/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/connectors/search/controllers/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AAChG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAChF,OAAO,EAAE,UAAU,EAAY,MAAM,wBAAwB,CAAC;AAE9D,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;2EACuE;IACvE,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;;;OAGG;IACH,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAlCd,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DhC"}

package/dist/connectors/search/controllers/factory.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchControllerFactory = void 0;
+const models_1 = require("../../../base/models");
+const ignis_helpers_1 = require("@venizia/ignis-helpers");
+const ignis_inversion_1 = require("@venizia/ignis-inversion");
+const abstract_1 = require("./abstract");
+const definition_1 = require("./definition");
+/** Factory for generating turnkey search controllers (single-collection + cross-collection) from entity definitions. */
+class SearchControllerFactory extends ignis_helpers_1.BaseHelper {
+    constructor() {
+        super({ scope: SearchControllerFactory.name });
+    }
+    /** Creates a search controller with two generated endpoints:
+     * 1. `POST {basePath}/search` (single-collection, via `repository.search()`)
+     * 2. `POST {basePath}/multi-search` (cross-collection, 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 (0, ignis_helpers_1.getError)({
+                message: `[defineSearchController] Invalid controller basePath | name: ${name} | basePath: ${basePath}`,
+            });
+        }
+        const entityClass = (0, ignis_inversion_1.isClass)(entity) ? entity : entity();
+        const entityInstance = new entityClass();
+        const selectSchema = entityInstance.getSchema({ type: models_1.SchemaTypes.SELECT });
+        const routeDefinitions = (0, definition_1.defineSearchRouteConfigs)({ selectSchema, authenticate, authorize });
+        const controllerClass = class extends abstract_1.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;
+    }
+}
+exports.SearchControllerFactory = SearchControllerFactory;
+//# sourceMappingURL=factory.js.map

package/dist/connectors/search/controllers/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../../../src/connectors/search/controllers/factory.ts"],"names":[],"mappings":";;;AAEA,0CAA4C;AAK5C,0DAA8D;AAC9D,8DAAmD;AAGnD,yCAAsD;AACtD,6CAAwD;AAoCxD,wHAAwH;AACxH,MAAa,uBAAwB,SAAQ,0BAAU;IACrD;QACE,KAAK,CAAC,EAAE,KAAK,EAAE,uBAAuB,CAAC,IAAI,EAAE,CAAC,CAAC;IACjD,CAAC;IAED;;;OAGG;IACH,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,IAAA,wBAAQ,EAAC;gBACb,OAAO,EAAE,gEAAgE,IAAI,gBAAgB,QAAQ,EAAE;aACxG,CAAC,CAAC;QACL,CAAC;QAED,MAAM,WAAW,GAAG,IAAA,yBAAO,EAAC,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,oBAAW,CAAC,MAAM,EAAE,CAAC,CAAC;QAC5E,MAAM,gBAAgB,GAAG,IAAA,qCAAwB,EAAC,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,CAAC,CAAC;QAE7F,MAAM,eAAe,GAAG,KAAM,SAAQ,mCAOrC;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;AA3ED,0DA2EC"}

package/dist/connectors/search/controllers/index.d.ts

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

package/dist/connectors/search/controllers/index.d.ts.map

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

package/dist/connectors/search/controllers/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abstract"), exports);
+__exportStar(require("./definition"), exports);
+__exportStar(require("./factory"), exports);
+//# sourceMappingURL=index.js.map

package/dist/connectors/search/controllers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/connectors/search/controllers/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA2B;AAC3B,+CAA6B;AAC7B,4CAA0B"}

package/dist/connectors/search/datasources/abstract.d.ts

@@ -0,0 +1,25 @@
+import { AbstractDataSource } from '../../../base/datasources';
+import type { ISearchConnector } from '../../../connectors/search/connector';
+import type { ISearchCollectionDefinition, TSearchSchema } from '../../../connectors/search/models';
+import type { ISearchQueryDialect, TMultiSearchEntry } from '../../../connectors/search/repositories/common';
+/** 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. The neutral return is `unknown` because each engine's multi-search
+     * envelope differs (Typesense `results[]`/union, Meilisearch `results[]`/federation); a concrete
+     * datasource narrows it. Declared here so a repository generic over its datasource 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/connectors/search/datasources/abstract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract.d.ts","sourceRoot":"","sources":["../../../../src/connectors/search/datasources/abstract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,KAAK,EAAE,2BAA2B,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC7F,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,yCAAyC,CAAC;AAEjD,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;;uGAEmG;IACnG,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/connectors/{typesense → search}/datasources/abstract.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractSearchDataSource = void 0;
 const datasources_1 = require("../../../base/datasources");
-/** Engine contract only (driver, dialect, collection compile/ensure) - mirrors AbstractPostgresDataSource. Discovery/provisioning lives on BaseSearchDataSource. */
+/** Engine contract only (connector, dialect, collection compile/ensure) - mirrors AbstractPostgresDataSource. Discovery/provisioning lives on BaseSearchDataSource. */
 class AbstractSearchDataSource extends datasources_1.AbstractDataSource {
 }
 exports.AbstractSearchDataSource = AbstractSearchDataSource;

package/dist/connectors/search/datasources/abstract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract.js","sourceRoot":"","sources":["../../../../src/connectors/search/datasources/abstract.ts"],"names":[],"mappings":";;;AAAA,oDAAwD;AAQxD,uKAAuK;AACvK,MAAsB,wBAEpB,SAAQ,gCAA2C;CAiBpD;AAnBD,4DAmBC"}