elasticlink 0.2.2-beta → 0.4.0-beta

package/dist/__tests__/integration/aggregation.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=aggregation.integration.test.d.ts.map

package/dist/__tests__/integration/aggregation.integration.test.d.ts.map

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

package/dist/__tests__/integration/aggregation.integration.test.js

@@ -0,0 +1,188 @@
+import { query, indexBuilder } from '../../index.js';
+import { createIndex, deleteIndex, indexDoc, refreshIndex, search } from './helpers.js';
+import { matterMappings, MATTERS } from './fixtures/legal.js';
+const INDEX = 'int-aggregation';
+describe('AggregationBuilder', () => {
+    beforeAll(async () => {
+        await createIndex(INDEX, indexBuilder().mappings(matterMappings).build());
+        for (const doc of MATTERS)
+            await indexDoc(INDEX, doc);
+        await refreshIndex(INDEX);
+    });
+    afterAll(() => deleteIndex(INDEX));
+    describe('Aggregation — terms', () => {
+        it('buckets documents by a keyword field', async () => {
+            const result = await search(INDEX, query(matterMappings)
+                .matchAll()
+                .aggs((agg) => agg.terms('by_area', 'practice_area'))
+                .size(0)
+                .build());
+            expect(result.aggregations.by_area.buckets).toMatchInlineSnapshot(`
+        [
+          {
+            "doc_count": 1,
+            "key": "corporate",
+          },
+          {
+            "doc_count": 1,
+            "key": "intellectual-property",
+          },
+          {
+            "doc_count": 1,
+            "key": "real-estate",
+          },
+          {
+            "doc_count": 1,
+            "key": "securities",
+          },
+        ]
+      `);
+        });
+        it('supports size option and sub-aggregations', async () => {
+            const result = await search(INDEX, query(matterMappings)
+                .matchAll()
+                .aggs((agg) => agg.terms('by_area', 'practice_area', { size: 2 }).subAgg((sub) => sub.avg('avg_rate', 'billing_rate')))
+                .size(0)
+                .build());
+            expect(result.aggregations.by_area.buckets).toMatchInlineSnapshot(`
+        [
+          {
+            "avg_rate": {
+              "value": 850,
+            },
+            "doc_count": 1,
+            "key": "corporate",
+          },
+          {
+            "avg_rate": {
+              "value": 780,
+            },
+            "doc_count": 1,
+            "key": "intellectual-property",
+          },
+        ]
+      `);
+        });
+    });
+    describe('Aggregation — metrics', () => {
+        it('computes avg, min, max, sum, and value_count in one request', async () => {
+            const result = await search(INDEX, query(matterMappings)
+                .matchAll()
+                .aggs((agg) => agg
+                .avg('avg_rate', 'billing_rate')
+                .min('min_rate', 'billing_rate')
+                .max('max_rate', 'billing_rate')
+                .sum('total_rate', 'billing_rate')
+                .valueCount('count', 'billing_rate'))
+                .size(0)
+                .build());
+            expect(result.aggregations).toMatchInlineSnapshot(`
+        {
+          "avg_rate": {
+            "value": 792.5,
+          },
+          "count": {
+            "value": 4,
+          },
+          "max_rate": {
+            "value": 920,
+          },
+          "min_rate": {
+            "value": 620,
+          },
+          "total_rate": {
+            "value": 3170,
+          },
+        }
+      `);
+        });
+        it('computes stats and cardinality', async () => {
+            const result = await search(INDEX, query(matterMappings)
+                .matchAll()
+                .aggs((agg) => agg.stats('rate_stats', 'billing_rate').cardinality('unique_areas', 'practice_area'))
+                .size(0)
+                .build());
+            expect(result.aggregations).toMatchInlineSnapshot(`
+        {
+          "rate_stats": {
+            "avg": 792.5,
+            "count": 4,
+            "max": 920,
+            "min": 620,
+            "sum": 3170,
+          },
+          "unique_areas": {
+            "value": 4,
+          },
+        }
+      `);
+        });
+    });
+    describe('Aggregation — range', () => {
+        it('buckets documents into named billing rate ranges', async () => {
+            const result = await search(INDEX, query(matterMappings)
+                .matchAll()
+                .aggs((agg) => agg.range('rate_bands', 'billing_rate', {
+                ranges: [
+                    { key: 'standard', to: 700 },
+                    { key: 'senior', from: 700, to: 850 },
+                    { key: 'partner', from: 850 }
+                ]
+            }))
+                .size(0)
+                .build());
+            expect(result.aggregations.rate_bands.buckets).toMatchInlineSnapshot(`
+        [
+          {
+            "doc_count": 1,
+            "key": "standard",
+            "to": 700,
+          },
+          {
+            "doc_count": 1,
+            "from": 700,
+            "key": "senior",
+            "to": 850,
+          },
+          {
+            "doc_count": 2,
+            "from": 850,
+            "key": "partner",
+          },
+        ]
+      `);
+        });
+    });
+    describe('Aggregation — dateHistogram', () => {
+        it('groups documents into yearly buckets', async () => {
+            const result = await search(INDEX, query(matterMappings)
+                .matchAll()
+                .aggs((agg) => agg.dateHistogram('by_year', 'opened_at', {
+                calendar_interval: 'year',
+                min_doc_count: 1,
+                format: 'yyyy'
+            }))
+                .size(0)
+                .build());
+            expect(result.aggregations.by_year.buckets.map((b) => ({
+                year: b.key_as_string,
+                doc_count: b.doc_count
+            }))).toMatchInlineSnapshot(`
+        [
+          {
+            "doc_count": 1,
+            "year": "2021",
+          },
+          {
+            "doc_count": 1,
+            "year": "2022",
+          },
+          {
+            "doc_count": 2,
+            "year": "2023",
+          },
+        ]
+      `);
+        });
+    });
+});

package/dist/__tests__/integration/bulk.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bulk.integration.test.d.ts.map

package/dist/__tests__/integration/bulk.integration.test.d.ts.map

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

package/dist/__tests__/integration/bulk.integration.test.js

@@ -0,0 +1,90 @@
+import { bulk, query, indexBuilder } from '../../index.js';
+import { createIndex, deleteIndex, refreshIndex, search, bulkRequest } from './helpers.js';
+import { tradeMappings } from './fixtures/finance.js';
+const INDEX = 'int-bulk';
+describe('BulkBuilder', () => {
+    beforeAll(() => createIndex(INDEX, indexBuilder().mappings(tradeMappings).build()));
+    afterAll(() => deleteIndex(INDEX));
+    describe('Bulk — index and create', () => {
+        it('indexes and creates documents via bulk, then retrieves them', async () => {
+            const ndjson = bulk(tradeMappings)
+                .index({ reference: 'TRD-001 AAPL Buy 100', status: 'settled', priority: 1 }, { _index: INDEX, _id: 'trd-1' })
+                .index({ reference: 'TRD-002 MSFT Sell 50', status: 'pending', priority: 2 }, { _index: INDEX, _id: 'trd-2' })
+                .create({ reference: 'TRD-003 GOOG Buy 25', status: 'pending', priority: 3 }, { _index: INDEX, _id: 'trd-3' })
+                .build();
+            const bulkResult = await bulkRequest(ndjson);
+            await refreshIndex(INDEX);
+            expect(bulkResult.errors).toBe(false);
+            const searchResult = await search(INDEX, query(tradeMappings).matchAll().build());
+            expect(searchResult.hits.total.value).toBe(3);
+        });
+    });
+    describe('Bulk — update', () => {
+        it('partially updates a document', async () => {
+            const ndjson = bulk(tradeMappings)
+                .update({ _index: INDEX, _id: 'trd-2', doc: { status: 'settled' } })
+                .build();
+            await bulkRequest(ndjson);
+            await refreshIndex(INDEX);
+            const result = await search(INDEX, query(tradeMappings).term('status', 'settled').build());
+            expect(result.hits.total.value).toBe(2);
+        });
+        it('upserts a document that does not exist', async () => {
+            const ndjson = bulk(tradeMappings)
+                .update({
+                _index: INDEX,
+                _id: 'trd-4',
+                doc: {
+                    reference: 'TRD-004 TSLA Buy 10',
+                    status: 'pending',
+                    priority: 4
+                },
+                doc_as_upsert: true
+            })
+                .build();
+            await bulkRequest(ndjson);
+            await refreshIndex(INDEX);
+            const result = await search(INDEX, query(tradeMappings).matchAll().build());
+            expect(result.hits.total.value).toBe(4);
+        });
+    });
+    describe('Bulk — delete', () => {
+        it('deletes a document via bulk', async () => {
+            const ndjson = bulk(tradeMappings).delete({ _index: INDEX, _id: 'trd-4' }).build();
+            await bulkRequest(ndjson);
+            await refreshIndex(INDEX);
+            const result = await search(INDEX, query(tradeMappings).matchAll().build());
+            expect(result.hits.total.value).toBe(3);
+        });
+    });
+    describe('Bulk — mixed operations', () => {
+        it('executes index, update, and delete in a single bulk call', async () => {
+            const ndjson = bulk(tradeMappings)
+                .index({ reference: 'TRD-099 NVDA Buy 5', status: 'pending', priority: 99 }, { _index: INDEX, _id: 'trd-temp' })
+                .update({ _index: INDEX, _id: 'trd-1', doc: { priority: 10 } })
+                .delete({ _index: INDEX, _id: 'trd-3' })
+                .build();
+            const bulkResult = await bulkRequest(ndjson);
+            expect(bulkResult.errors).toBe(false);
+            expect(bulkResult.items.map((i) => {
+                const [op] = Object.keys(i);
+                return { op, result: i[op].result };
+            })).toMatchInlineSnapshot(`
+        [
+          {
+            "op": "index",
+            "result": "created",
+          },
+          {
+            "op": "update",
+            "result": "updated",
+          },
+          {
+            "op": "delete",
+            "result": "deleted",
+          },
+        ]
+      `);
+        });
+    });
+});

package/dist/__tests__/integration/fixtures/finance.d.ts

@@ -0,0 +1,37 @@
+import type { Infer } from '../../../index.js';
+export declare const instrumentMappings: Readonly<{
+    _fieldTypes: {
+        name: "text";
+        asset_class: "keyword";
+        sector: "keyword";
+        tags: "keyword";
+        price: "integer";
+        yield_rate: "float";
+        active: "boolean";
+        listed_date: "date";
+    };
+    properties: Record<string, import("../../../index-management.types.js").FieldMapping>;
+    _mappingOptions?: import("../../../mapping.types.js").MappingOptions;
+}>;
+export type Instrument = Infer<typeof instrumentMappings>;
+export declare const INSTRUMENTS: {
+    name: string;
+    asset_class: string;
+    sector: string;
+    tags: string[];
+    price: number;
+    yield_rate: number;
+    active: boolean;
+    listed_date: string;
+}[];
+export declare const tradeMappings: Readonly<{
+    _fieldTypes: {
+        reference: "text";
+        status: "keyword";
+        priority: "integer";
+    };
+    properties: Record<string, import("../../../index-management.types.js").FieldMapping>;
+    _mappingOptions?: import("../../../mapping.types.js").MappingOptions;
+}>;
+export type Trade = Infer<typeof tradeMappings>;
+//# sourceMappingURL=finance.d.ts.map

package/dist/__tests__/integration/fixtures/finance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finance.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/integration/fixtures/finance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE/C,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;EAS7B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE1D,eAAO,MAAM,WAAW;;;;;;;;;GAyCvB,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;EAIxB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/__tests__/integration/fixtures/finance.js

@@ -0,0 +1,58 @@
+import { mappings, text, keyword, integer, float, date, boolean } from '../../../index.js';
+export const instrumentMappings = mappings({
+    name: text(),
+    asset_class: keyword(),
+    sector: keyword(),
+    tags: keyword(),
+    price: integer(),
+    yield_rate: float(),
+    active: boolean(),
+    listed_date: date()
+});
+export const INSTRUMENTS = [
+    {
+        name: 'US Treasury 10-Year Note',
+        asset_class: 'fixed-income',
+        sector: 'government',
+        tags: ['sovereign', 'investment-grade', 'liquid'],
+        price: 98,
+        yield_rate: 4.3,
+        active: true,
+        listed_date: '2023-02-15'
+    },
+    {
+        name: 'Investment Grade Corporate Bond ETF',
+        asset_class: 'fixed-income',
+        sector: 'corporate',
+        tags: ['etf', 'investment-grade', 'diversified'],
+        price: 112,
+        yield_rate: 5.1,
+        active: true,
+        listed_date: '2023-07-01'
+    },
+    {
+        name: 'Emerging Market Equity Fund',
+        asset_class: 'equity',
+        sector: 'emerging-markets',
+        tags: ['high-risk', 'growth', 'diversified'],
+        price: 54,
+        yield_rate: 2.8,
+        active: false,
+        listed_date: '2022-09-12'
+    },
+    {
+        name: 'S&P 500 Index Fund',
+        asset_class: 'equity',
+        sector: 'broad-market',
+        tags: ['index', 'sp500', 'liquid'],
+        price: 479,
+        yield_rate: 1.5,
+        active: true,
+        listed_date: '2021-03-22'
+    }
+];
+export const tradeMappings = mappings({
+    reference: text(),
+    status: keyword(),
+    priority: integer()
+});

package/dist/__tests__/integration/fixtures/legal.d.ts

@@ -0,0 +1,38 @@
+import type { Infer } from '../../../index.js';
+export declare const matterMappings: Readonly<{
+    _fieldTypes: {
+        title: "text";
+        practice_area: "keyword";
+        billing_rate: "integer";
+        risk_score: "float";
+        opened_at: "date";
+    };
+    properties: Record<string, import("../../../index-management.types.js").FieldMapping>;
+    _mappingOptions?: import("../../../mapping.types.js").MappingOptions;
+}>;
+export type Matter = Infer<typeof matterMappings>;
+export declare const MATTERS: {
+    title: string;
+    practice_area: string;
+    billing_rate: number;
+    risk_score: number;
+    opened_at: string;
+}[];
+export declare const attorneyMappings: Readonly<{
+    _fieldTypes: {
+        name: "text";
+        practice_area: "keyword";
+        name_suggest: "completion";
+    };
+    properties: Record<string, import("../../../index-management.types.js").FieldMapping>;
+    _mappingOptions?: import("../../../mapping.types.js").MappingOptions;
+}>;
+export type Attorney = Infer<typeof attorneyMappings>;
+export declare const ATTORNEYS: {
+    name: string;
+    practice_area: string;
+    name_suggest: {
+        input: string[];
+    };
+}[];
+//# sourceMappingURL=legal.d.ts.map

package/dist/__tests__/integration/fixtures/legal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legal.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/integration/fixtures/legal.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE/C,eAAO,MAAM,cAAc;;;;;;;;;;EAMzB,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAElD,eAAO,MAAM,OAAO;;;;;;GA6BnB,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;EAI3B,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEtD,eAAO,MAAM,SAAS;;;;;;GAqBrB,CAAC"}

package/dist/__tests__/integration/fixtures/legal.js

@@ -0,0 +1,65 @@
+import { mappings, text, keyword, integer, float, date, completion } from '../../../index.js';
+export const matterMappings = mappings({
+    title: text(),
+    practice_area: keyword(),
+    billing_rate: integer(),
+    risk_score: float(),
+    opened_at: date()
+});
+export const MATTERS = [
+    {
+        title: 'Mergers & Acquisitions Advisory',
+        practice_area: 'corporate',
+        billing_rate: 850,
+        risk_score: 3.2,
+        opened_at: '2023-01-10'
+    },
+    {
+        title: 'SEC Enforcement Defense',
+        practice_area: 'securities',
+        billing_rate: 920,
+        risk_score: 4.7,
+        opened_at: '2023-05-22'
+    },
+    {
+        title: 'Patent Infringement Litigation',
+        practice_area: 'intellectual-property',
+        billing_rate: 780,
+        risk_score: 3.9,
+        opened_at: '2022-08-14'
+    },
+    {
+        title: 'Commercial Real Estate Finance',
+        practice_area: 'real-estate',
+        billing_rate: 620,
+        risk_score: 2.1,
+        opened_at: '2021-11-03'
+    }
+];
+export const attorneyMappings = mappings({
+    name: text(),
+    practice_area: keyword(),
+    name_suggest: completion()
+});
+export const ATTORNEYS = [
+    {
+        name: 'Sarah Chen',
+        practice_area: 'corporate',
+        name_suggest: { input: ['Sarah Chen', 'Chen'] }
+    },
+    {
+        name: 'Marcus Williams',
+        practice_area: 'securities',
+        name_suggest: { input: ['Marcus Williams', 'Williams'] }
+    },
+    {
+        name: 'Priya Kapoor',
+        practice_area: 'intellectual-property',
+        name_suggest: { input: ['Priya Kapoor', 'Kapoor'] }
+    },
+    {
+        name: 'James Okafor',
+        practice_area: 'real-estate',
+        name_suggest: { input: ['James Okafor', 'Okafor'] }
+    }
+];

package/dist/__tests__/integration/fixtures/real-estate.d.ts

@@ -0,0 +1,17 @@
+import type { Infer } from '../../../index.js';
+export declare const listingMappings: Readonly<{
+    _fieldTypes: {
+        address: "text";
+        property_class: "keyword";
+        list_price: "integer";
+    };
+    properties: Record<string, import("../../../index-management.types.js").FieldMapping>;
+    _mappingOptions?: import("../../../mapping.types.js").MappingOptions;
+}>;
+export type Listing = Infer<typeof listingMappings>;
+export declare const LISTINGS: {
+    address: string;
+    property_class: string;
+    list_price: number;
+}[];
+//# sourceMappingURL=real-estate.d.ts.map

package/dist/__tests__/integration/fixtures/real-estate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"real-estate.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/integration/fixtures/real-estate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE/C,eAAO,MAAM,eAAe;;;;;;;;EAI1B,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAEpD,eAAO,MAAM,QAAQ;;;;GAqBpB,CAAC"}

package/dist/__tests__/integration/fixtures/real-estate.js

@@ -0,0 +1,28 @@
+import { mappings, text, keyword, integer } from '../../../index.js';
+export const listingMappings = mappings({
+    address: text(),
+    property_class: keyword(),
+    list_price: integer()
+});
+export const LISTINGS = [
+    {
+        address: '200 Harbor View Dr, Unit 12A',
+        property_class: 'condo',
+        list_price: 1_250_000
+    },
+    {
+        address: '845 Park Avenue, Apt 8B',
+        property_class: 'condo',
+        list_price: 2_100_000
+    },
+    {
+        address: '12 Park Terrace',
+        property_class: 'townhouse',
+        list_price: 3_100_000
+    },
+    {
+        address: '500 Riverside Drive',
+        property_class: 'townhouse',
+        list_price: 4_800_000
+    }
+];

package/dist/__tests__/integration/helpers.d.ts

@@ -0,0 +1,15 @@
+export type EsRequest = {
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    path?: string;
+    body?: any;
+};
+export declare const createIndex: (index: string, config: any) => Promise<any>;
+export declare const deleteIndex: (index: string) => Promise<any>;
+export declare const refreshIndex: (index: string) => Promise<any>;
+export declare const search: (index: string, body: any) => Promise<any>;
+export declare const indexDoc: (index: string, body: any) => Promise<any>;
+export declare const bulkRequest: (ndjson: string) => Promise<any>;
+export declare const msearchRequest: (index: string, ndjson: string) => Promise<any>;
+export declare const esGet: (path: string) => Promise<any>;
+export declare const esPost: (path: string, body?: any) => Promise<any>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/__tests__/integration/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/__tests__/integration/helpers.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,CAAC;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ,CAAC;AAgBF,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,EAAE,QAAQ,GAAG,iBAAgD,CAAC;AAEvG,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,iBAA2C,CAAC;AAErF,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,iBAAkD,CAAC;AAE7F,eAAO,MAAM,MAAM,GAAI,OAAO,MAAM,EAAE,MAAM,GAAG,iBAAuD,CAAC;AAEvG,eAAO,MAAM,QAAQ,GAAI,OAAO,MAAM,EAAE,MAAM,GAAG,iBAAoD,CAAC;AAEtG,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,iBAAwC,CAAC;AAEnF,eAAO,MAAM,cAAc,GAAI,OAAO,MAAM,EAAE,QAAQ,MAAM,iBAAoD,CAAC;AAEjH,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,iBAAsC,CAAC;AAEzE,eAAO,MAAM,MAAM,GAAI,MAAM,MAAM,EAAE,OAAO,GAAG,iBAA6C,CAAC"}

package/dist/__tests__/integration/helpers.js

@@ -0,0 +1,21 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const ES_URL = process.env.ELASTICSEARCH_URL || 'http://localhost:9200';
+const esJson = (url, method, body) => fetch(url, {
+    method,
+    headers: { 'Content-Type': 'application/json' },
+    ...(body && { body: JSON.stringify(body) })
+}).then((r) => r.json());
+const esNdjson = (url, body) => fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-ndjson' },
+    body
+}).then((r) => r.json());
+export const createIndex = (index, config) => esJson(`${ES_URL}/${index}`, 'PUT', config);
+export const deleteIndex = (index) => esJson(`${ES_URL}/${index}`, 'DELETE');
+export const refreshIndex = (index) => esJson(`${ES_URL}/${index}/_refresh`, 'POST');
+export const search = (index, body) => esJson(`${ES_URL}/${index}/_search`, 'POST', body);
+export const indexDoc = (index, body) => esJson(`${ES_URL}/${index}/_doc`, 'POST', body);
+export const bulkRequest = (ndjson) => esNdjson(`${ES_URL}/_bulk`, ndjson);
+export const msearchRequest = (index, ndjson) => esNdjson(`${ES_URL}/${index}/_msearch`, ndjson);
+export const esGet = (path) => esJson(`${ES_URL}${path}`, 'GET');
+export const esPost = (path, body) => esJson(`${ES_URL}${path}`, 'POST', body);

package/dist/__tests__/integration/index-management.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index-management.integration.test.d.ts.map

package/dist/__tests__/integration/index-management.integration.test.d.ts.map

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

package/dist/__tests__/integration/index-management.integration.test.js

@@ -0,0 +1,67 @@
+import { indexBuilder, mappings, text, keyword, integer, float, date, boolean, geoPoint, denseVector, nested, completion } from '../../index.js';
+import { createIndex, deleteIndex, esGet } from './helpers.js';
+const INDEX_FULL = 'int-index-mgmt-full';
+const INDEX_ALIAS = 'int-index-mgmt-alias';
+const fullDocMappings = mappings({
+    title: text(),
+    category: keyword(),
+    count: integer(),
+    score: float(),
+    created_at: date(),
+    active: boolean(),
+    location: geoPoint(),
+    embedding: denseVector({ dims: 3 }),
+    tags: nested({ label: keyword(), weight: float() }),
+    suggest: completion()
+});
+const fieldTypes = (props) => Object.fromEntries(Object.entries(props).map(([k, v]) => [k, v.type]));
+describe('Index Management — full index config', () => {
+    beforeAll(() => createIndex(INDEX_FULL, indexBuilder().mappings(fullDocMappings).settings({ number_of_shards: 1, number_of_replicas: 0 }).build()));
+    afterAll(() => deleteIndex(INDEX_FULL));
+    it('registers all field types in the mapping', async () => {
+        const result = await esGet(`/${INDEX_FULL}/_mapping`);
+        expect(fieldTypes(result[INDEX_FULL].mappings.properties)).toMatchInlineSnapshot(`
+      {
+        "active": "boolean",
+        "category": "keyword",
+        "count": "integer",
+        "created_at": "date",
+        "embedding": "dense_vector",
+        "location": "geo_point",
+        "score": "float",
+        "suggest": "completion",
+        "tags": "nested",
+        "title": "text",
+      }
+    `);
+    });
+    it('applies index settings', async () => {
+        const result = await esGet(`/${INDEX_FULL}/_settings`);
+        const { [INDEX_FULL]: { settings: { index: { number_of_shards, number_of_replicas } } } } = result;
+        expect({ number_of_shards, number_of_replicas }).toMatchInlineSnapshot(`
+      {
+        "number_of_replicas": "0",
+        "number_of_shards": "1",
+      }
+    `);
+    });
+});
+describe('Index Management — aliases', () => {
+    beforeAll(() => createIndex(INDEX_ALIAS, indexBuilder()
+        .mappings({ title: text() })
+        .alias('int-alias-read')
+        .alias('int-alias-write', { is_write_index: true })
+        .build()));
+    afterAll(() => deleteIndex(INDEX_ALIAS));
+    it('creates aliases with correct configuration', async () => {
+        const result = await esGet(`/${INDEX_ALIAS}/_alias`);
+        expect(result[INDEX_ALIAS].aliases).toMatchInlineSnapshot(`
+      {
+        "int-alias-read": {},
+        "int-alias-write": {
+          "is_write_index": true,
+        },
+      }
+    `);
+    });
+});