@venizia/ignis-connectors 0.2.0-0

package/dist/cjs/search/core/repositories/common/types.d.ts

@@ -0,0 +1,126 @@
+import type { TFilter, TWhere } from '@venizia/ignis-kernel';
+import type { TConstValue } from '@venizia/ignis-helpers/common';
+import type { SearchModes, TSearchInput } from './constants';
+/**
+ * What a `where` tree compiled down to. A filter STRING cannot express the two absorbing
+ * outcomes: `''` is indistinguishable from "no constraint", which is why an empty `or` used to
+ * compile to a filter byte-identical to the unscoped query - widening the very clause meant to
+ * narrow it. The relational branch has always had this vocabulary (`sql\`false\`` vs `undefined`,
+ * relational/repositories/dialect/filter.ts:637-641); this is that vocabulary for the search branch.
+ */
+export declare class SearchFilterOutcomes {
+    /** A real filter expression the engine should run. */
+    static readonly FILTER = "filter";
+    /** Vacuously true - impose no constraint. */
+    static readonly MATCH_ALL = "matchAll";
+    /** Absorbing false - can never match, so the engine must not be asked. */
+    static readonly MATCH_NONE = "matchNone";
+    static readonly SCHEME_SET: Set<string>;
+    static isValid(input: string): input is TSearchFilterOutcome;
+}
+export type TSearchFilterOutcome = TConstValue<typeof SearchFilterOutcomes>;
+export type TCompiledWhere = {
+    outcome: typeof SearchFilterOutcomes.FILTER;
+    filterBy: string;
+} | {
+    outcome: typeof SearchFilterOutcomes.MATCH_ALL;
+} | {
+    outcome: typeof SearchFilterOutcomes.MATCH_NONE;
+};
+/**
+ * Query-time capabilities a dialect compiles against. Passed per call, never stored: every
+ * datasource shares ONE dialect instance (`typesense/datasources/datasource.ts:29` holds it in a
+ * static), so a dialect that remembered a collection would answer the next collection's query
+ * with the previous one's fields.
+ */
+export interface ISearchCompileCapabilities {
+    /**
+     * Field names the collection declares. ABSENT means "unvalidated" - an entity carrying no
+     * collection definition must still compile, exactly as it did before field checking existed.
+     */
+    fields?: ReadonlySet<string>;
+}
+/** Search-engine query parameters translated from a repository-level TFilter. Only the cross-engine intersection lives here - an engine's own tuning knobs go on its own extension. Field names stay camelCase; wire format is produced only at the dialect's `toWireParams` boundary. */
+export interface ISearchQuery {
+    /** Full-text search term. Use '*' for pure filter listings. */
+    query: string;
+    filterBy?: string;
+    sortBy?: string;
+    page?: number;
+    perPage?: number;
+    includeFields?: string;
+    excludeFields?: string;
+    offset?: number;
+    queryBy?: string;
+    queryByWeights?: string;
+    facetBy?: string;
+    facetQuery?: string;
+    maxFacetValues?: number;
+    highlightFields?: string;
+    highlightFullFields?: string;
+    highlightStartTag?: string;
+    highlightEndTag?: string;
+    snippetThreshold?: number;
+    groupBy?: string;
+    groupLimit?: number;
+    groupMissingValues?: boolean;
+    /** Engine-native wire parameters, merged last into `toWireParams` output verbatim and unvalidated; keys use the engine's own vocabulary (`num_typos`, not `numTypos`). */
+    engineParams?: Record<string, unknown>;
+    /** The `where` compiled to an absorbing false: no query can match, so the repository answers empty WITHOUT calling the engine. Internal - `toWireParams` strips it, so it never reaches the wire. */
+    matchNone?: boolean;
+}
+/** Translates repository-level `TFilter`/`TWhere` into a search-engine-specific query. */
+export interface ISearchQueryDialect {
+    build(opts: {
+        filter?: TFilter;
+        hiddenFields?: string[];
+        capabilities?: ISearchCompileCapabilities;
+    }): ISearchQuery;
+    /**
+     * @deprecated Use `compileWhere`, which can express the absorbing outcomes a filter STRING
+     * cannot. This signature has no representation for "matches nothing" - it returned `''`, which
+     * the caller could not tell from "no constraint", so an empty `or` widened the query it was
+     * meant to narrow. It now THROWS on that input rather than answering wrongly.
+     */
+    toWhere(opts: {
+        where: TWhere;
+    }): string;
+    /**
+     * Compiles a `where` tree, resolving what a filter string cannot express. `capabilities` is
+     * per-call, never retained - one dialect instance serves every datasource.
+     */
+    compileWhere(opts: {
+        where: TWhere;
+        capabilities?: ISearchCompileCapabilities;
+    }): TCompiledWhere;
+    /**
+     * Whether this engine can express `operator` at all. Published by the dialect rather than
+     * hand-copied by callers, so it cannot drift from the engine's own `switch`; every member of
+     * `QueryOperators.SCHEME_SET` has an answer, which is what stops a new engine from silently
+     * leaving one unclassified.
+     */
+    canExpress(opts: {
+        operator: string;
+    }): boolean;
+    /**
+     * ANDs already-compiled clauses using this engine's own conjunction, honouring the absorbing
+     * outcomes. The repository needs this to combine a caller clause with a repository-owned one it
+     * compiled SEPARATELY - the joiner belongs to the engine, so the dialect supplies it rather
+     * than the caller guessing `&&` versus `AND`.
+     */
+    conjoin(opts: {
+        clauses: TCompiledWhere[];
+    }): TCompiledWhere;
+    /** Writes every engine-specific consequence of a non-raw search input onto `query` (mode dispatch, vector clause, tuning knobs) - keeping `ReadableSearchRepository` engine-free. */
+    applySearchInput(opts: {
+        query: ISearchQuery;
+        input: Exclude<TSearchInput, {
+            mode: typeof SearchModes.RAW;
+        }>;
+    }): void;
+    /** Maps a camelCase query record onto the engine's wire-format field names via a key lookup, never a wire-cased identifier; `engineParams` merges last. */
+    toWireParams(opts: {
+        query: Partial<ISearchQuery>;
+    }): Record<string, unknown>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/cjs/search/core/repositories/common/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/search/core/repositories/common/types.ts"],"names":[],"mappings":"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"}

package/dist/cjs/search/core/repositories/common/types.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchFilterOutcomes = void 0;
+/**
+ * What a `where` tree compiled down to. A filter STRING cannot express the two absorbing
+ * outcomes: `''` is indistinguishable from "no constraint", which is why an empty `or` used to
+ * compile to a filter byte-identical to the unscoped query - widening the very clause meant to
+ * narrow it. The relational branch has always had this vocabulary (`sql\`false\`` vs `undefined`,
+ * relational/repositories/dialect/filter.ts:637-641); this is that vocabulary for the search branch.
+ */
+class SearchFilterOutcomes {
+    /** A real filter expression the engine should run. */
+    static { this.FILTER = 'filter'; }
+    /** Vacuously true - impose no constraint. */
+    static { this.MATCH_ALL = 'matchAll'; }
+    /** Absorbing false - can never match, so the engine must not be asked. */
+    static { this.MATCH_NONE = 'matchNone'; }
+    static { this.SCHEME_SET = new Set([this.FILTER, this.MATCH_ALL, this.MATCH_NONE]); }
+    static isValid(input) {
+        return this.SCHEME_SET.has(input);
+    }
+}
+exports.SearchFilterOutcomes = SearchFilterOutcomes;
+//# sourceMappingURL=types.js.map

package/dist/cjs/search/core/repositories/common/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../src/search/core/repositories/common/types.ts"],"names":[],"mappings":";;;AAIA;;;;;;GAMG;AACH,MAAa,oBAAoB;IAC/B,sDAAsD;aACtC,WAAM,GAAG,QAAQ,CAAC;IAClC,6CAA6C;aAC7B,cAAS,GAAG,UAAU,CAAC;IACvC,0EAA0E;aAC1D,eAAU,GAAG,WAAW,CAAC;aAEzB,eAAU,GAAG,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;IAErF,MAAM,CAAC,OAAO,CAAC,KAAa;QAC1B,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;;AAZH,oDAaC"}

package/dist/cjs/search/core/repositories/core/base.d.ts

@@ -0,0 +1,91 @@
+import type { ITransaction } from '@venizia/ignis-kernel';
+import type { TFilter, TLockOptions, TWhere } from '@venizia/ignis-kernel';
+import { AbstractRepository } from '@venizia/ignis-kernel';
+import type { AbstractSearchDataSource } from '../../../../search/core/datasources';
+import type { BaseSearchEntity } from '../../../../search/core/models';
+import type { TClass } from '@venizia/ignis-helpers/common';
+import type { ISearchQuery, ISearchQueryDialect, TCompiledWhere } from '../../../../search/core/repositories/common';
+/** Search-repository plumbing on `AbstractRepository`. `TDataSource` carries the concrete connector type through `this.connector`, so a concretely-bound repository reaches its engine's verbs uncast while an engine-agnostic one is forced to write `connector.alias?.…`. */
+export declare abstract class SearchBaseRepository<TDocument extends object = object, TDataSource extends AbstractSearchDataSource = AbstractSearchDataSource> extends AbstractRepository<TDocument, TDocument> {
+    constructor(dataSource?: TDataSource, opts?: {
+        scope?: string;
+        entityClass?: TClass<BaseSearchEntity>;
+    });
+    get dataSource(): TDataSource;
+    set dataSource(value: TDataSource);
+    get entity(): BaseSearchEntity;
+    set entity(value: BaseSearchEntity);
+    get collectionName(): string;
+    protected get connector(): ReturnType<TDataSource['getConnector']>;
+    protected get queryDialect(): ISearchQueryDialect;
+    get multiSearch(): TDataSource['multiSearch'];
+    setDataSource(opts: {
+        dataSource: TDataSource;
+    }): void;
+    /** WRITE responses never pass through the engine's exclude-fields filter, so hiddenProperties are stripped here - the relational branch gets the same guarantee from `.returning(visibleProperties)`. */
+    protected omitHiddenFields<R>(document: R): R;
+    protected omitHiddenFieldsAll<R>(documents: R[]): R[];
+    /** No search engine here has a transaction primitive (this tier is engine-neutral - Typesense and Meilisearch both inherit it) - a caller-supplied options.transaction is rejected loudly instead of silently running outside the transaction the caller expects. */
+    protected assertNoTransaction(opts?: {
+        transaction?: ITransaction;
+    }): void;
+    /** Row-level locking (SELECT ... FOR UPDATE) has no search-engine equivalent - same NotSupported convention as assertNoTransaction. */
+    protected assertNoLock(opts?: {
+        lock?: TLockOptions;
+    }): void;
+    private _collectionFields?;
+    /**
+     * Field names the collection declares, or undefined when it declares none - which means
+     * "unvalidated", not "no fields": an entity carrying no `ISearchCollectionDefinition` must
+     * compile exactly as it did before field checking existed.
+     *
+     * Read from the entity's own typed `schema` rather than by casting into `entity.constructor`;
+     * `BaseSearchEntity.schema` is instance-side and already an `ISearchCollectionDefinition`.
+     * Memoized per repository instance - the definition is frozen after boot.
+     */
+    protected get collectionFields(): ReadonlySet<string> | undefined;
+    /**
+     * Builds a dialect-translated query, always stripping hiddenFields.
+     *
+     * The caller's `where` and the repository-owned `defaultWhere` are compiled SEPARATELY and
+     * combined after, rather than merged into one tree first. Merging first makes the two
+     * indistinguishable, and the repository's own clause would then have to satisfy the
+     * caller-facing field check: `SprocketDocument` in integration-wiring.test.ts declares
+     * [title, secretCode] but carries `defaultFilter: { where: { isActive: true } }`, so every
+     * request through it would 400 ITSELF. Compiling separately makes the trust boundary a matter
+     * of WHICH CALL IS MADE, which - unlike a flag threaded through the recursion - cannot be wrong
+     * at a nested level.
+     */
+    protected buildQuery(opts: {
+        filter?: TFilter;
+        shouldSkipDefaultFilter?: boolean;
+    }): ISearchQuery;
+    /**
+     * Refuses a caller-supplied page larger than this model allows.
+     *
+     * POLICY, and the counterweight to a guardrail this tier removed: an engine used to refuse more
+     * than 250 hits per page, so an unreasonable `limit` failed fast and cheap. Now that such a page
+     * is served, something has to decide when it is unreasonable, and the framework would otherwise
+     * be less safe than before it could satisfy the request.
+     *
+     * It lives in `buildQuery` because that is the one point BOTH `find()` and `search()` pass
+     * through - enforcing in `find()` alone would leave `search()` as a way around it, which is not
+     * a ceiling. `mode: 'raw'` bypasses `buildQuery` and therefore bypasses this deliberately: raw
+     * is the documented escape hatch and its callers own the consequences. They still cannot exceed
+     * the connector's physical ceiling, which is the intended layering - policy is opt-out-able,
+     * physics is not.
+     */
+    protected assertLimitWithinCeiling(opts: {
+        limit?: number;
+    }): void;
+    /**
+     * Compiles the caller clause (field-checked) and the repository-owned default clause
+     * (unchecked), then ANDs them via the dialect - `defaultWhere` first, preserving the order the
+     * previous `{ and: [defaultWhere, where] }` merge produced.
+     */
+    protected compileEffectiveWhere(opts: {
+        where?: TWhere;
+        defaultWhere?: TWhere;
+    }): TCompiledWhere;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/cjs/search/core/repositories/core/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../../../src/search/core/repositories/core/base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAI3D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,KAAK,EACV,YAAY,EACZ,mBAAmB,EACnB,cAAc,EACf,MAAM,mCAAmC,CAAC;AAG3C,+QAA+Q;AAC/Q,8BAAsB,oBAAoB,CACxC,SAAS,SAAS,MAAM,GAAG,MAAM,EACjC,WAAW,SAAS,wBAAwB,GAAG,wBAAwB,CACvE,SAAQ,kBAAkB,CAAC,SAAS,EAAE,SAAS,CAAC;gBAE9C,UAAU,CAAC,EAAE,WAAW,EACxB,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC,gBAAgB,CAAC,CAAA;KAAE;IAKnE,IAAa,UAAU,IAAI,WAAW,CAErC;IAED,IAAa,UAAU,CAAC,KAAK,EAAE,WAAW,EAEzC;IAED,IAAa,MAAM,IAAI,gBAAgB,CAEtC;IAED,IAAa,MAAM,CAAC,KAAK,EAAE,gBAAgB,EAE1C;IAED,IAAI,cAAc,IAAI,MAAM,CAE3B;IAED,SAAS,KAAK,SAAS,IAAI,UAAU,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC,CAEjE;IAED,SAAS,KAAK,YAAY,IAAI,mBAAmB,CAEhD;IAED,IAAI,WAAW,IAAI,WAAW,CAAC,aAAa,CAAC,CAE5C;IAEQ,aAAa,CAAC,IAAI,EAAE;QAAE,UAAU,EAAE,WAAW,CAAA;KAAE,GAAG,IAAI;IAI/D,yMAAyM;IACzM,SAAS,CAAC,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC;IAgB7C,SAAS,CAAC,mBAAmB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE;IAQrD,qQAAqQ;IACrQ,SAAS,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,YAAY,CAAA;KAAE,GAAG,IAAI;IAY1E,uIAAuI;IACvI,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,YAAY,CAAA;KAAE,GAAG,IAAI;IAY5D,OAAO,CAAC,iBAAiB,CAAC,CAAc;IAExC;;;;;;;;OAQG;IACH,SAAS,KAAK,gBAAgB,IAAI,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,CAOhE;IAED;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE;QACzB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,uBAAuB,CAAC,EAAE,OAAO,CAAC;KACnC,GAAG,YAAY;IAoChB;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,wBAAwB,CAAC,IAAI,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAclE;;;;OAIG;IACH,SAAS,CAAC,qBAAqB,CAAC,IAAI,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,cAAc;CAiBjG"}

package/dist/cjs/search/core/repositories/core/base.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchBaseRepository = void 0;
+const ignis_kernel_1 = require("@venizia/ignis-kernel");
+const ignis_kernel_2 = require("@venizia/ignis-kernel");
+const common_1 = require("../../../../search/core/common");
+const core_1 = require("@venizia/ignis-helpers/core");
+const ignis_kernel_3 = require("@venizia/ignis-kernel");
+const common_2 = require("../../../../search/core/repositories/common");
+/** Search-repository plumbing on `AbstractRepository`. `TDataSource` carries the concrete connector type through `this.connector`, so a concretely-bound repository reaches its engine's verbs uncast while an engine-agnostic one is forced to write `connector.alias?.…`. */
+class SearchBaseRepository extends ignis_kernel_1.AbstractRepository {
+    constructor(dataSource, opts) {
+        super(dataSource, opts);
+    }
+    get dataSource() {
+        return super.dataSource;
+    }
+    set dataSource(value) {
+        super.dataSource = value;
+    }
+    get entity() {
+        return super.entity;
+    }
+    set entity(value) {
+        super.entity = value;
+    }
+    get collectionName() {
+        return this.entity.name;
+    }
+    get connector() {
+        return this.dataSource.getConnector();
+    }
+    get queryDialect() {
+        return this.dataSource.getQueryDialect();
+    }
+    get multiSearch() {
+        return this.dataSource.multiSearch.bind(this.dataSource);
+    }
+    setDataSource(opts) {
+        super.setDataSource(opts);
+    }
+    /** WRITE responses never pass through the engine's exclude-fields filter, so hiddenProperties are stripped here - the relational branch gets the same guarantee from `.returning(visibleProperties)`. */
+    omitHiddenFields(document) {
+        const hiddenFields = this.hiddenFields;
+        if (hiddenFields.length === 0 || document === null || typeof document !== 'object') {
+            return document;
+        }
+        const visible = { ...document };
+        for (const field of hiddenFields) {
+            delete visible[field];
+        }
+        return visible;
+    }
+    omitHiddenFieldsAll(documents) {
+        if (this.hiddenFields.length === 0) {
+            return documents;
+        }
+        return documents.map(document => this.omitHiddenFields(document));
+    }
+    /** No search engine here has a transaction primitive (this tier is engine-neutral - Typesense and Meilisearch both inherit it) - a caller-supplied options.transaction is rejected loudly instead of silently running outside the transaction the caller expects. */
+    assertNoTransaction(opts) {
+        if (!opts?.transaction) {
+            return;
+        }
+        (0, ignis_kernel_3.throwNotSupported)({
+            scope: this.dataSource.constructor.name,
+            feature: 'Transactions',
+            logger: this.logger,
+        });
+    }
+    /** Row-level locking (SELECT ... FOR UPDATE) has no search-engine equivalent - same NotSupported convention as assertNoTransaction. */
+    assertNoLock(opts) {
+        if (!opts?.lock) {
+            return;
+        }
+        (0, ignis_kernel_3.throwNotSupported)({
+            scope: this.dataSource.constructor.name,
+            feature: 'Row-level locking',
+            logger: this.logger,
+        });
+    }
+    /**
+     * Field names the collection declares, or undefined when it declares none - which means
+     * "unvalidated", not "no fields": an entity carrying no `ISearchCollectionDefinition` must
+     * compile exactly as it did before field checking existed.
+     *
+     * Read from the entity's own typed `schema` rather than by casting into `entity.constructor`;
+     * `BaseSearchEntity.schema` is instance-side and already an `ISearchCollectionDefinition`.
+     * Memoized per repository instance - the definition is frozen after boot.
+     */
+    get collectionFields() {
+        if (!this._collectionFields) {
+            const fields = this.entity?.schema?.fields;
+            this._collectionFields = new Set((fields ?? []).map(field => field.name));
+        }
+        return this._collectionFields.size > 0 ? this._collectionFields : undefined;
+    }
+    /**
+     * Builds a dialect-translated query, always stripping hiddenFields.
+     *
+     * The caller's `where` and the repository-owned `defaultWhere` are compiled SEPARATELY and
+     * combined after, rather than merged into one tree first. Merging first makes the two
+     * indistinguishable, and the repository's own clause would then have to satisfy the
+     * caller-facing field check: `SprocketDocument` in integration-wiring.test.ts declares
+     * [title, secretCode] but carries `defaultFilter: { where: { isActive: true } }`, so every
+     * request through it would 400 ITSELF. Compiling separately makes the trust boundary a matter
+     * of WHICH CALL IS MADE, which - unlike a flag threaded through the recursion - cannot be wrong
+     * at a nested level.
+     */
+    buildQuery(opts) {
+        const { filter, shouldSkipDefaultFilter } = opts;
+        const defaultWhere = shouldSkipDefaultFilter ? undefined : this.defaultWhere;
+        this.assertLimitWithinCeiling({ limit: filter?.limit });
+        // `where` is withheld from `build` and compiled below: handing it over merged would field-check
+        // the repository's own clause along with the caller's.
+        const query = this.queryDialect.build({
+            filter: filter ? { ...filter, where: undefined } : undefined,
+            hiddenFields: this.hiddenFields,
+            capabilities: { fields: this.collectionFields },
+        });
+        const compiled = this.compileEffectiveWhere({ where: filter?.where, defaultWhere });
+        switch (compiled.outcome) {
+            case common_2.SearchFilterOutcomes.FILTER: {
+                query.filterBy = compiled.filterBy;
+                break;
+            }
+            case common_2.SearchFilterOutcomes.MATCH_NONE: {
+                query.matchNone = true;
+                break;
+            }
+            case common_2.SearchFilterOutcomes.MATCH_ALL:
+            default: {
+                // Vacuously true - nothing to set and nothing to short-circuit. Spelled out rather than
+                // left as an unwritten else, so all three outcomes are visibly accounted for.
+                break;
+            }
+        }
+        return query;
+    }
+    /**
+     * Refuses a caller-supplied page larger than this model allows.
+     *
+     * POLICY, and the counterweight to a guardrail this tier removed: an engine used to refuse more
+     * than 250 hits per page, so an unreasonable `limit` failed fast and cheap. Now that such a page
+     * is served, something has to decide when it is unreasonable, and the framework would otherwise
+     * be less safe than before it could satisfy the request.
+     *
+     * It lives in `buildQuery` because that is the one point BOTH `find()` and `search()` pass
+     * through - enforcing in `find()` alone would leave `search()` as a way around it, which is not
+     * a ceiling. `mode: 'raw'` bypasses `buildQuery` and therefore bypasses this deliberately: raw
+     * is the documented escape hatch and its callers own the consequences. They still cannot exceed
+     * the connector's physical ceiling, which is the intended layering - policy is opt-out-able,
+     * physics is not.
+     */
+    assertLimitWithinCeiling(opts) {
+        const { limit } = opts;
+        const ceiling = this.maxLimit ?? ignis_kernel_2.DEFAULT_MAX_LIMIT;
+        if (limit === undefined || limit <= ceiling) {
+            return;
+        }
+        throw (0, core_1.getError)({
+            error: common_1.SearchErrors.PAGE_TOO_LARGE,
+            message: `[${this.constructor.name}][buildQuery] Requested page exceeds this model's limit | collection: '${this.collectionName}' | requested: ${limit} | maximum: ${ceiling} | raise it with @model settings.maxLimit if larger pages are genuinely needed`,
+        });
+    }
+    /**
+     * Compiles the caller clause (field-checked) and the repository-owned default clause
+     * (unchecked), then ANDs them via the dialect - `defaultWhere` first, preserving the order the
+     * previous `{ and: [defaultWhere, where] }` merge produced.
+     */
+    compileEffectiveWhere(opts) {
+        const { where, defaultWhere } = opts;
+        const dialect = this.queryDialect;
+        const clauses = [];
+        if (defaultWhere) {
+            clauses.push(dialect.compileWhere({ where: defaultWhere }));
+        }
+        if (where) {
+            clauses.push(dialect.compileWhere({ where, capabilities: { fields: this.collectionFields } }));
+        }
+        return dialect.conjoin({ clauses });
+    }
+}
+exports.SearchBaseRepository = SearchBaseRepository;
+//# sourceMappingURL=base.js.map

package/dist/cjs/search/core/repositories/core/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../../../src/search/core/repositories/core/base.ts"],"names":[],"mappings":"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"}

package/dist/cjs/search/core/repositories/core/default.d.ts

@@ -0,0 +1,6 @@
+import type { AbstractSearchDataSource } from '../../../../search/core/datasources';
+import { PersistableSearchRepository } from './persistable';
+/** Full CRUD search-repository tier - convenience alias over `PersistableSearchRepository` (which already carries every write, including delete). */
+export declare class DefaultSearchRepository<TDocument extends object = object, TDataSource extends AbstractSearchDataSource = AbstractSearchDataSource> extends PersistableSearchRepository<TDocument, TDataSource> {
+}
+//# sourceMappingURL=default.d.ts.map

package/dist/cjs/search/core/repositories/core/default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../../../../src/search/core/repositories/core/default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAE5D,qJAAqJ;AACrJ,qBAAa,uBAAuB,CAClC,SAAS,SAAS,MAAM,GAAG,MAAM,EACjC,WAAW,SAAS,wBAAwB,GAAG,wBAAwB,CACvE,SAAQ,2BAA2B,CAAC,SAAS,EAAE,WAAW,CAAC;CAAG"}

package/dist/cjs/search/core/repositories/core/default.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSearchRepository = void 0;
+const persistable_1 = require("./persistable");
+/** Full CRUD search-repository tier - convenience alias over `PersistableSearchRepository` (which already carries every write, including delete). */
+class DefaultSearchRepository extends persistable_1.PersistableSearchRepository {
+}
+exports.DefaultSearchRepository = DefaultSearchRepository;
+//# sourceMappingURL=default.js.map

package/dist/cjs/search/core/repositories/core/default.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.js","sourceRoot":"","sources":["../../../../../../src/search/core/repositories/core/default.ts"],"names":[],"mappings":";;;AACA,+CAA4D;AAE5D,qJAAqJ;AACrJ,MAAa,uBAGX,SAAQ,yCAAmD;CAAG;AAHhE,0DAGgE"}

package/dist/cjs/search/core/repositories/core/index.d.ts

@@ -0,0 +1,6 @@
+export { SearchBaseRepository as TypesenseBaseRepository } from './base';
+export * from './base';
+export * from './readable';
+export * from './persistable';
+export * from './default';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/search/core/repositories/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/search/core/repositories/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,IAAI,uBAAuB,EAAE,MAAM,QAAQ,CAAC;AACzE,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC"}

package/dist/cjs/search/core/repositories/core/index.js

@@ -0,0 +1,24 @@
+"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 });
+exports.TypesenseBaseRepository = void 0;
+var base_1 = require("./base");
+Object.defineProperty(exports, "TypesenseBaseRepository", { enumerable: true, get: function () { return base_1.SearchBaseRepository; } });
+__exportStar(require("./base"), exports);
+__exportStar(require("./readable"), exports);
+__exportStar(require("./persistable"), exports);
+__exportStar(require("./default"), exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/search/core/repositories/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../src/search/core/repositories/core/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,+BAAyE;AAAhE,+GAAA,oBAAoB,OAA2B;AACxD,yCAAuB;AACvB,6CAA2B;AAC3B,gDAA8B;AAC9B,4CAA0B"}

package/dist/cjs/search/core/repositories/core/persistable.d.ts

@@ -0,0 +1,126 @@
+import type { IdType } from '@venizia/ignis-kernel';
+import type { IExtraOptions, TCount, TWhere } from '@venizia/ignis-kernel';
+import type { AbstractSearchDataSource } from '../../../../search/core/datasources';
+import type { BaseSearchEntity } from '../../../../search/core/models';
+import type { TClass } from '@venizia/ignis-helpers/common';
+import type { IImportResult } from '../../../../search/core';
+import { ReadableSearchRepository } from './readable';
+/** Write-tier search-repository - creates/updates through the connector, dialect-translating `where` clauses. */
+export declare class PersistableSearchRepository<TDocument extends object = object, TDataSource extends AbstractSearchDataSource = AbstractSearchDataSource> extends ReadableSearchRepository<TDocument, TDataSource> {
+    constructor(ds?: TDataSource, opts?: {
+        scope?: string;
+        entityClass?: TClass<BaseSearchEntity>;
+    });
+    create(opts: {
+        data: TDocument;
+        options: IExtraOptions & {
+            shouldReturn: false;
+        };
+    }): Promise<TCount & {
+        data: undefined | null;
+    }>;
+    create<R = TDocument>(opts: {
+        data: TDocument;
+        options?: IExtraOptions & {
+            shouldReturn?: true;
+        };
+    }): Promise<TCount & {
+        data: R;
+    }>;
+    createAll(opts: {
+        data: Array<TDocument>;
+        options: IExtraOptions & {
+            shouldReturn: false;
+            batchSize?: number;
+        };
+    }): Promise<TCount & {
+        data: undefined | null;
+    }>;
+    createAll<R = TDocument>(opts: {
+        data: Array<TDocument>;
+        options?: IExtraOptions & {
+            shouldReturn?: true;
+            batchSize?: number;
+        };
+    }): Promise<TCount & {
+        data: Array<R>;
+    }>;
+    updateById(opts: {
+        id: IdType;
+        data: Partial<TDocument>;
+        options: IExtraOptions & {
+            shouldReturn: false;
+        };
+    }): Promise<TCount & {
+        data: undefined | null;
+    }>;
+    updateById<R = TDocument>(opts: {
+        id: IdType;
+        data: Partial<TDocument>;
+        options?: IExtraOptions & {
+            shouldReturn?: true;
+        };
+    }): Promise<TCount & {
+        data: R;
+    }>;
+    /** Count-only: search engines have no RETURNING and no extra read is bolted on, so `data` is always `null` and `shouldReturn` is rejected at the type level - callers wanting the affected documents read them before updating. */
+    updateAll(opts: {
+        data: Partial<TDocument>;
+        where?: TWhere;
+        options?: Omit<IExtraOptions, 'shouldReturn'> & {
+            force?: boolean;
+        };
+    }): Promise<TCount & {
+        data: null;
+    }>;
+    deleteById(opts: {
+        id: IdType;
+        options: IExtraOptions & {
+            shouldReturn: false;
+        };
+    }): Promise<TCount & {
+        data: undefined | null;
+    }>;
+    deleteById<R = TDocument>(opts: {
+        id: IdType;
+        options?: IExtraOptions & {
+            shouldReturn?: true;
+        };
+    }): Promise<TCount & {
+        data: R;
+    }>;
+    /** Count-only like updateAll: filter-delete when there is an effective where, truncating the whole collection only when neither where nor defaultFilter is present - truncate reports no per-document count, so that path returns { count: 0, data: null }. */
+    deleteAll(opts?: {
+        where?: TWhere;
+        options?: Omit<IExtraOptions, 'shouldReturn'> & {
+            force?: boolean;
+        };
+    }): Promise<TCount & {
+        data: null;
+    }>;
+    /** Bulk import through the neutral document facade. Per-row write `action` is Typesense-only vocabulary - callers needing it use `dataSource.getConnector().importDocuments(...)` directly. */
+    import(opts: {
+        documents: TDocument[];
+        batchSize?: number;
+    }): Promise<IImportResult<unknown>>;
+    /** Resolves filterBy, AND-merging defaultWhere unless shouldSkipDefaultFilter. Returns undefined when there's no effective where - callers decide (updateAll refuses; deleteAll truncates). */
+    protected buildFilterBy(opts: {
+        where?: TWhere;
+        shouldSkipDefaultFilter?: boolean;
+    }): string | undefined;
+    /**
+     * The write-path filter as THREE outcomes, because two of them are catastrophically different
+     * here: `filterBy: undefined` means "no effective where", which `deleteAll` treats as licence to
+     * truncate when `force` is set. An absorbing where must never land there -
+     * `deleteAll({ where: { or: permittedIds.map(...) } })` on an EMPTY permission list has to
+     * delete nothing, not the entire collection. `matchNone` is what keeps the two apart.
+     */
+    protected buildScopedFilter(opts: {
+        where?: TWhere;
+        shouldSkipDefaultFilter?: boolean;
+    }): {
+        filterBy?: string;
+        matchNone: boolean;
+    };
+}
+//# sourceMappingURL=persistable.d.ts.map