@azure/search-documents
Version:
Azure client library to use AI Search for node.js and browser.
817 lines • 30.4 kB
JavaScript
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
import { logger } from "./logger.js";
import { isComplexField } from "./serviceModels.js";
export const defaultServiceVersion = "2026-04-01";
const knownSkills = {
"#Microsoft.Skills.Custom.ChatCompletionSkill": true,
"#Microsoft.Skills.Custom.WebApiSkill": true,
"#Microsoft.Skills.Text.AzureOpenAIEmbeddingSkill": true,
"#Microsoft.Skills.Text.CustomEntityLookupSkill": true,
"#Microsoft.Skills.Text.EntityRecognitionSkill": true,
"#Microsoft.Skills.Text.KeyPhraseExtractionSkill": true,
"#Microsoft.Skills.Text.LanguageDetectionSkill": true,
"#Microsoft.Skills.Text.MergeSkill": true,
"#Microsoft.Skills.Text.PIIDetectionSkill": true,
"#Microsoft.Skills.Text.SentimentSkill": true,
"#Microsoft.Skills.Text.SplitSkill": true,
"#Microsoft.Skills.Text.TranslationSkill": true,
"#Microsoft.Skills.Text.V3.EntityLinkingSkill": true,
"#Microsoft.Skills.Text.V3.EntityRecognitionSkill": true,
"#Microsoft.Skills.Text.V3.SentimentSkill": true,
"#Microsoft.Skills.Util.ConditionalSkill": true,
"#Microsoft.Skills.Util.DocumentExtractionSkill": true,
"#Microsoft.Skills.Util.ShaperSkill": true,
"#Microsoft.Skills.Vision.ImageAnalysisSkill": true,
"#Microsoft.Skills.Vision.OcrSkill": true,
"#Microsoft.Skills.Custom.AmlSkill": true,
"#Microsoft.Skills.Vision.VectorizeSkill": true,
"#Microsoft.Skills.Util.DocumentIntelligenceLayoutSkill": true,
"#Microsoft.Skills.Util.ContentUnderstandingSkill": true,
};
export function convertSkillsToPublic(skills) {
if (!skills) {
return [];
}
// This validation has already GAed
return skills.filter((skill) => knownSkills[skill.odatatype]);
}
export function convertCognitiveServicesAccountToGenerated(cognitiveServicesAccount) {
if (!cognitiveServicesAccount) {
return cognitiveServicesAccount;
}
switch (cognitiveServicesAccount.odatatype) {
case "#Microsoft.Azure.Search.AIServicesByIdentity":
case "#Microsoft.Azure.Search.DefaultCognitiveServices":
case "#Microsoft.Azure.Search.CognitiveServicesByKey":
case "#Microsoft.Azure.Search.AIServicesByKey":
return cognitiveServicesAccount;
default: {
logger.warning(`Unsupported Cognitive Services account odatatype: ${cognitiveServicesAccount.odatatype}`);
return cognitiveServicesAccount;
}
}
}
export function convertCognitiveServicesAccountToPublic(cognitiveServicesAccount) {
if (!cognitiveServicesAccount) {
return undefined;
}
const deserializers = {
"#Microsoft.Azure.Search.DefaultCognitiveServices": () => {
return cognitiveServicesAccount;
},
"#Microsoft.Azure.Search.CognitiveServicesByKey": () => {
return cognitiveServicesAccount;
},
"#Microsoft.Azure.Search.AIServicesByKey": () => {
return cognitiveServicesAccount;
},
"#Microsoft.Azure.Search.AIServicesByIdentity": () => {
const { identity, ...restParams } = cognitiveServicesAccount;
return {
...restParams,
identity: convertSearchIndexerDataIdentityToPublic(identity),
};
},
};
const defaultDeserializer = () => {
logger.warning(`Unsupported Cognitive Services account odatatype: ${cognitiveServicesAccount.odatatype}`);
return cognitiveServicesAccount;
};
return (deserializers[cognitiveServicesAccount.odatatype] ?? defaultDeserializer)();
}
export function convertTokenFiltersToGenerated(tokenFilters) {
if (!tokenFilters) {
return tokenFilters;
}
const result = [];
for (const filter of tokenFilters) {
result.push(filter);
}
return result;
}
function convertAnalyzersToGenerated(analyzers) {
if (!analyzers) {
return analyzers;
}
const result = [];
for (const analyzer of analyzers) {
switch (analyzer.odatatype) {
case "#Microsoft.Azure.Search.StandardAnalyzer":
case "#Microsoft.Azure.Search.StopAnalyzer":
result.push(analyzer);
break;
case "#Microsoft.Azure.Search.PatternAnalyzer":
result.push(analyzer);
break;
case "#Microsoft.Azure.Search.CustomAnalyzer":
result.push({
...analyzer,
tokenizer: analyzer.tokenizerName,
});
break;
}
}
return result;
}
function convertAnalyzersToPublic(analyzers) {
if (!analyzers) {
return undefined;
}
const result = [];
for (const analyzer of analyzers) {
switch (analyzer.odatatype) {
case "#Microsoft.Azure.Search.StandardAnalyzer":
result.push(analyzer);
break;
case "#Microsoft.Azure.Search.StopAnalyzer":
result.push(analyzer);
break;
case "#Microsoft.Azure.Search.PatternAnalyzer":
result.push({
...analyzer,
});
break;
case "#Microsoft.Azure.Search.CustomAnalyzer":
result.push(analyzer);
break;
}
}
return result;
}
export function convertFieldsToPublic(fields) {
if (!fields) {
return undefined;
}
return fields.map((field) => {
if (field.type === "Collection(Edm.ComplexType)" || field.type === "Edm.ComplexType") {
const result = {
name: field.name,
type: field.type,
fields: convertFieldsToPublic(field.fields),
};
return result;
}
else {
const type = field.type;
const synonymMapNames = field.synonymMapNames;
const { retrievable, ...restField } = field;
const hidden = typeof retrievable === "boolean" ? !retrievable : retrievable;
const result = {
...restField,
type,
hidden,
synonymMapNames,
};
return result;
}
});
}
export function convertFieldsToGenerated(fields) {
return fields?.map((field) => {
if (isComplexField(field)) {
return {
name: field.name,
type: field.type,
fields: convertFieldsToGenerated(field.fields),
};
}
else {
const { hidden, ...restField } = field;
const retrievable = typeof hidden === "boolean" ? !hidden : hidden;
return {
...restField,
retrievable,
// modify API defaults to use less storage for simple types
searchable: field.searchable ?? false,
filterable: field.filterable ?? false,
facetable: field.facetable ?? false,
sortable: field.sortable ?? false,
analyzerName: field.analyzerName,
searchAnalyzerName: field.searchAnalyzerName,
indexAnalyzerName: field.indexAnalyzerName,
synonymMapNames: field.synonymMapNames,
normalizerName: field.normalizerName,
};
}
});
}
function convertTokenizersToPublic(tokenizers) {
if (!tokenizers) {
return undefined;
}
const result = [];
for (const tokenizer of tokenizers) {
result.push(tokenizer);
}
return result;
}
export function convertSimilarityToGenerated(similarity) {
if (!similarity) {
return similarity;
}
return similarity;
}
export function convertSimilarityToPublic(similarity) {
if (!similarity) {
return undefined;
}
if (similarity.odatatype === "#Microsoft.Azure.Search.ClassicSimilarity") {
return similarity;
}
else {
return similarity;
}
}
function convertEncryptionKeyToPublic(encryptionKey) {
if (!encryptionKey) {
return undefined;
}
const result = {
keyName: encryptionKey.keyName,
keyVersion: encryptionKey.keyVersion,
vaultUrl: encryptionKey.vaultUri,
identity: convertSearchIndexerDataIdentityToPublic(encryptionKey.identity),
applicationId: encryptionKey.applicationId,
applicationSecret: encryptionKey.applicationSecret,
};
return result;
}
function convertEncryptionKeyToGenerated(encryptionKey) {
if (!encryptionKey) {
return undefined;
}
const result = {
keyName: encryptionKey.keyName,
keyVersion: encryptionKey.keyVersion,
vaultUri: encryptionKey.vaultUrl,
identity: encryptionKey.identity,
applicationId: encryptionKey.applicationId,
applicationSecret: encryptionKey.applicationSecret,
};
return result;
}
export function generatedIndexToPublicIndex(generatedIndex) {
const { charFilters, tokenFilters, scoringProfiles, encryptionKey, analyzers, tokenizers, fields, similarity, vectorSearch, ...rest } = generatedIndex;
return {
...rest,
scoringProfiles: scoringProfiles,
tokenFilters: tokenFilters,
charFilters: charFilters,
encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
analyzers: convertAnalyzersToPublic(analyzers),
tokenizers: convertTokenizersToPublic(tokenizers),
fields: convertFieldsToPublic(fields),
similarity: convertSimilarityToPublic(similarity),
vectorSearch: generatedVectorSearchToPublicVectorSearch(vectorSearch),
};
}
export function generatedVectorSearchVectorizerToPublicVectorizer(generatedVectorizer) {
if (!generatedVectorizer) {
return undefined;
}
const knownVectorizerDeserializers = {
azureOpenAI: () => {
const { parameters } = generatedVectorizer;
const authIdentity = convertSearchIndexerDataIdentityToPublic(parameters?.authIdentity);
const vectorizer = {
...generatedVectorizer,
parameters: { ...parameters, authIdentity },
};
return vectorizer;
},
customWebApi: () => {
const { webApiParameters } = generatedVectorizer;
const authIdentity = convertSearchIndexerDataIdentityToPublic(webApiParameters?.authIdentity);
const vectorizer = {
...generatedVectorizer,
parameters: { ...webApiParameters, authIdentity },
};
return vectorizer;
},
aml: () => {
const generatedAMLVectorizer = generatedVectorizer;
const vectorizer = {
...generatedAMLVectorizer,
amlParameters: generatedAzureMachineLearningVectorizerParametersToPublicAzureMachineLearningVectorizerParameters(generatedAMLVectorizer.amlParameters),
};
return vectorizer;
},
};
const defaultDeserializer = () => {
logger.warning(`Unsupported vectorizer kind: ${generatedVectorizer.kind}`);
return generatedVectorizer;
};
return (knownVectorizerDeserializers[generatedVectorizer.kind] ?? defaultDeserializer)();
}
export function generatedKnowledgeSourceVectorizerToPublicVectorizer(
// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
generatedVectorizer) {
if (!generatedVectorizer) {
return generatedVectorizer;
}
const knownVectorizerDeserializers = {
azureOpenAI: () => {
const { parameters } = generatedVectorizer;
const authIdentity = convertSearchIndexerDataIdentityToPublic(parameters?.authIdentity);
const vectorizer = {
...generatedVectorizer,
parameters: { ...parameters, authIdentity },
};
return vectorizer;
},
};
const defaultDeserializer = () => {
logger.warning(`Unsupported vectorizer kind: ${generatedVectorizer.kind}`);
return generatedVectorizer;
};
return (knownVectorizerDeserializers[generatedVectorizer.kind] ?? defaultDeserializer)();
}
function generatedAzureMachineLearningVectorizerParametersToPublicAzureMachineLearningVectorizerParameters(aMLParameters) {
if (!aMLParameters) {
return undefined;
}
const { resourceId, authenticationKey, scoringUri } = aMLParameters;
// Sensitive to case order
switch (true) {
case resourceId !== undefined && resourceId !== null: {
return {
...aMLParameters,
authKind: "token",
};
}
case authenticationKey !== undefined && authenticationKey !== null: {
return {
...aMLParameters,
apiKey: authenticationKey,
authKind: "key",
};
}
case scoringUri !== undefined && scoringUri !== null: {
return {
...aMLParameters,
authKind: "none",
};
}
}
logger.warning("Unknown AML parameter kind");
return aMLParameters;
}
export function generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration(generatedAlgorithmConfiguration) {
if (!generatedAlgorithmConfiguration) {
return undefined;
}
if (["hnsw", "exhaustiveKnn"].includes(generatedAlgorithmConfiguration.kind)) {
const algorithmConfiguration = generatedAlgorithmConfiguration;
const metric = algorithmConfiguration.parameters?.metric;
return {
...algorithmConfiguration,
parameters: { ...algorithmConfiguration.parameters, metric },
};
}
throw Error("Unsupported algorithm configuration");
}
export function generatedVectorSearchToPublicVectorSearch(vectorSearch) {
if (!vectorSearch) {
return undefined;
}
return {
...vectorSearch,
algorithms: vectorSearch.algorithms?.map(generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration),
vectorizers: vectorSearch.vectorizers?.map(generatedVectorSearchVectorizerToPublicVectorizer),
};
}
export function generatedSearchResultToPublicSearchResult(results) {
const returnValues = results.map((result) => {
const { score, highlights, rerankerScore, rerankerBoostedScore, captions, documentDebugInfo, additionalProperties, } = result;
const obj = {
score,
highlights,
rerankerScore,
rerankerBoostedScore,
captions: convertGeneratedCaptionsToPublic(captions),
documentDebugInfo,
// The generated code puts document fields in additionalProperties
document: additionalProperties ?? {},
};
return obj;
});
return returnValues;
}
export function generatedSuggestDocumentsResultToPublicSuggestDocumentsResult(searchDocumentsResult) {
const results = searchDocumentsResult.results.map((element) => {
const { text, additionalProperties } = element;
const obj = {
text,
// The generated code puts document fields in additionalProperties
document: additionalProperties ?? {},
};
return obj;
});
const result = {
results: results,
coverage: searchDocumentsResult.coverage,
};
return result;
}
export function publicIndexToGeneratedIndex(index) {
const { encryptionKey, tokenFilters, analyzers, fields, similarity } = index;
return {
...index,
encryptionKey: convertEncryptionKeyToGenerated(encryptionKey),
tokenFilters: convertTokenFiltersToGenerated(tokenFilters),
analyzers: convertAnalyzersToGenerated(analyzers),
fields: convertFieldsToGenerated(fields) ?? [],
similarity: convertSimilarityToGenerated(similarity),
};
}
export function generatedSkillsetToPublicSkillset(generatedSkillset) {
const { skills, cognitiveServicesAccount, knowledgeStore, encryptionKey, indexProjection, ...props } = generatedSkillset;
return {
...props,
skills: convertSkillsToPublic(skills),
cognitiveServicesAccount: convertCognitiveServicesAccountToPublic(cognitiveServicesAccount),
knowledgeStore: convertKnowledgeStoreToPublic(knowledgeStore),
encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
indexProjection: indexProjection,
};
}
export function publicSkillsetToGeneratedSkillset(skillset) {
const { cognitiveServicesAccount, encryptionKey } = skillset;
return {
...skillset,
cognitiveServicesAccount: convertCognitiveServicesAccountToGenerated(cognitiveServicesAccount),
encryptionKey: convertEncryptionKeyToGenerated(encryptionKey),
};
}
export function generatedSynonymMapToPublicSynonymMap(synonymMap) {
const result = {
name: synonymMap.name,
encryptionKey: convertEncryptionKeyToPublic(synonymMap.encryptionKey),
etag: synonymMap.eTag,
synonyms: [],
};
if (synonymMap.synonyms) {
result.synonyms = synonymMap.synonyms;
}
return result;
}
export function publicSynonymMapToGeneratedSynonymMap(synonymMap) {
const result = {
name: synonymMap.name,
format: "solr",
encryptionKey: convertEncryptionKeyToGenerated(synonymMap.encryptionKey),
eTag: synonymMap.etag,
synonyms: synonymMap.synonyms,
};
result.encryptionKey = convertEncryptionKeyToGenerated(synonymMap.encryptionKey);
return result;
}
export function publicSearchIndexerToGeneratedSearchIndexer(indexer) {
return {
...indexer,
encryptionKey: convertEncryptionKeyToGenerated(indexer.encryptionKey),
};
}
export function generatedSearchIndexerToPublicSearchIndexer(indexer) {
const { parsingMode, dataToExtract, imageAction, pdfTextRotationAlgorithm, executionEnvironment, } = indexer.parameters?.configuration ?? {};
const configuration = indexer.parameters
?.configuration && {
...indexer.parameters?.configuration,
parsingMode: parsingMode,
dataToExtract: dataToExtract,
imageAction: imageAction,
pdfTextRotationAlgorithm: pdfTextRotationAlgorithm,
executionEnvironment: executionEnvironment,
markdownParsingSubmode: indexer.parameters?.configuration?.markdownParsingSubmode,
markdownHeaderDepth: indexer.parameters?.configuration?.markdownHeaderDepth,
};
const parameters = {
...indexer.parameters,
configuration,
batchSize: indexer.parameters?.batchSize,
maxFailedItems: indexer.parameters?.maxFailedItems,
maxFailedItemsPerBatch: indexer.parameters?.maxFailedItemsPerBatch,
};
return {
...indexer,
parameters,
encryptionKey: convertEncryptionKeyToPublic(indexer.encryptionKey),
schedule: indexer.schedule,
isDisabled: indexer.isDisabled,
};
}
export function publicDataSourceToGeneratedDataSource(dataSource) {
return {
name: dataSource.name,
description: dataSource.description,
type: dataSource.type,
connectionString: dataSource.connectionString,
container: dataSource.container,
identity: dataSource.identity,
eTag: dataSource.etag,
dataChangeDetectionPolicy: dataSource.dataChangeDetectionPolicy,
dataDeletionDetectionPolicy: dataSource.dataDeletionDetectionPolicy,
encryptionKey: convertEncryptionKeyToGenerated(dataSource.encryptionKey),
};
}
export function generatedDataSourceToPublicDataSource(dataSource) {
return {
name: dataSource.name,
description: dataSource.description,
type: dataSource.type,
connectionString: dataSource.connectionString,
container: dataSource.container,
identity: convertSearchIndexerDataIdentityToPublic(dataSource.identity),
etag: dataSource.eTag,
dataChangeDetectionPolicy: convertDataChangeDetectionPolicyToPublic(dataSource.dataChangeDetectionPolicy),
dataDeletionDetectionPolicy: convertDataDeletionDetectionPolicyToPublic(dataSource.dataDeletionDetectionPolicy),
encryptionKey: convertEncryptionKeyToPublic(dataSource.encryptionKey),
};
}
export function convertSearchIndexerDataIdentityToPublic(searchIndexerDataIdentity) {
if (!searchIndexerDataIdentity) {
return undefined;
}
if (searchIndexerDataIdentity.odatatype === "#Microsoft.Azure.Search.DataNoneIdentity") {
return searchIndexerDataIdentity;
}
else {
return searchIndexerDataIdentity;
}
}
export function convertDataChangeDetectionPolicyToPublic(dataChangeDetectionPolicy) {
if (!dataChangeDetectionPolicy) {
return undefined;
}
if (dataChangeDetectionPolicy.odatatype ===
"#Microsoft.Azure.Search.HighWaterMarkChangeDetectionPolicy") {
return dataChangeDetectionPolicy;
}
else {
return dataChangeDetectionPolicy;
}
}
export function convertDataDeletionDetectionPolicyToPublic(dataDeletionDetectionPolicy) {
if (!dataDeletionDetectionPolicy) {
return undefined;
}
return dataDeletionDetectionPolicy;
}
function convertKnowledgeStoreToPublic(knowledgeStore) {
if (!knowledgeStore) {
return undefined;
}
return {
...knowledgeStore,
identity: convertSearchIndexerDataIdentityToPublic(knowledgeStore.identity),
};
}
export function convertKnowledgeBaseToPublic(knowledgeBase) {
if (!knowledgeBase) {
throw new Error("Knowledge base is undefined");
}
return {
...knowledgeBase,
etag: knowledgeBase.etag,
models: (knowledgeBase.models ?? []).map((model) => convertKnowledgeBaseModelToPublic(model)),
encryptionKey: convertEncryptionKeyToPublic(knowledgeBase.encryptionKey),
};
}
export function convertKnowledgeBaseToGenerated(knowledgeBase) {
if (!knowledgeBase) {
return undefined;
}
return {
...knowledgeBase,
etag: knowledgeBase.etag,
encryptionKey: convertEncryptionKeyToGenerated(knowledgeBase.encryptionKey),
};
}
export function convertKnowledgeSourceToPublic(knowledgeSource) {
if (!knowledgeSource) {
return undefined;
}
switch (knowledgeSource.kind) {
case "searchIndex": {
const { encryptionKey } = knowledgeSource;
return {
...knowledgeSource,
encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
};
}
case "azureBlob": {
const { encryptionKey, azureBlobParameters } = knowledgeSource;
return {
...knowledgeSource,
kind: "azureBlob",
encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
azureBlobParameters: convertAzureBlobKnowledgeSourceParametersToPublic(azureBlobParameters),
};
}
case "indexedOneLake": {
const { encryptionKey, indexedOneLakeParameters } = knowledgeSource;
return {
...knowledgeSource,
kind: "indexedOneLake",
encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
indexedOneLakeParameters: {
fabricWorkspaceId: indexedOneLakeParameters.fabricWorkspaceId,
lakehouseId: indexedOneLakeParameters.lakehouseId,
ingestionParameters: convertKnowledgeIngestionParametersToPublic(indexedOneLakeParameters.ingestionParameters),
targetPath: indexedOneLakeParameters.targetPath,
createdResources: indexedOneLakeParameters.createdResources?.additionalProperties,
},
};
}
case "web": {
const { encryptionKey } = knowledgeSource;
return {
...knowledgeSource,
kind: "web",
encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
};
}
default: {
logger.warning(`Unknown knowledge source kind ${knowledgeSource.kind}`);
return undefined;
}
}
}
export function convertKnowledgeSourceToGenerated(knowledgeSource) {
if (!knowledgeSource) {
return undefined;
}
const { encryptionKey } = knowledgeSource;
return {
...knowledgeSource,
encryptionKey: convertEncryptionKeyToGenerated(encryptionKey),
};
}
function convertKnowledgeIngestionParametersToPublic(params) {
if (!params) {
return undefined;
}
const { embeddingModel, chatCompletionModel, identity, ...rest } = params;
return {
...rest,
embeddingModel: !embeddingModel
? embeddingModel
: generatedKnowledgeSourceVectorizerToPublicVectorizer(embeddingModel),
identity: convertSearchIndexerDataIdentityToPublic(identity),
chatCompletionModel: !chatCompletionModel
? chatCompletionModel
: convertKnowledgeBaseModelToPublic(chatCompletionModel),
};
}
function convertAzureBlobKnowledgeSourceParametersToPublic(params) {
if (!params) {
return undefined;
}
const { embeddingModel, chatCompletionModel, identity, ...rest } = params.ingestionParameters ?? {};
return {
...rest,
embeddingModel: !embeddingModel
? embeddingModel
: generatedKnowledgeSourceVectorizerToPublicVectorizer(embeddingModel),
identity: convertSearchIndexerDataIdentityToPublic(identity),
connectionString: params.connectionString,
containerName: params.containerName,
chatCompletionModel: !chatCompletionModel
? chatCompletionModel
: convertKnowledgeBaseModelToPublic(chatCompletionModel),
};
}
function convertKnowledgeBaseModelToPublic(model) {
switch (model.kind) {
case "azureOpenAI": {
const { azureOpenAIParameters, ...rest } = model;
return {
...rest,
azureOpenAIParameters: convertAzureOpenAIParametersToPublic(azureOpenAIParameters),
};
}
default: {
logger.warning("Unknown knowledge base model kind");
return model;
}
}
}
function convertAzureOpenAIParametersToPublic(params) {
return {
...params,
authIdentity: convertSearchIndexerDataIdentityToPublic(params.authIdentity),
};
}
export function mapPagedAsyncIterable(iter, mapper) {
return {
async next() {
const result = await iter.next();
return {
...result,
value: result.value && mapper(result.value),
};
},
[Symbol.asyncIterator]() {
return this;
},
async *byPage(settings) {
const iteratorByPage = iter.byPage(settings);
for await (const page of iteratorByPage) {
yield page.map(mapper);
}
},
};
}
/**
* Converts public IndexDocumentsAction format to generated IndexAction format.
* The public API uses `__actionType` with document properties spread at the root,
* while the generated API expects `actionType` with document properties in `additionalProperties`.
* @internal
*/
export function convertPublicActionsToGeneratedActions(actions) {
return actions.map((action) => {
const { __actionType, ...documentProperties } = action;
return {
actionType: __actionType,
additionalProperties: documentProperties,
};
});
}
// Backward compatibility conversion functions for FacetResult, QueryAnswerResult, and QueryCaptionResult
// These functions spread additionalProperties onto the top level of the object for backward compatibility
// with the old API where users could access dynamic properties directly (e.g., facetResult["myProperty"])
/**
* Converts a generated FacetResult to a public FacetResult with additionalProperties spread
* onto the object for backward compatibility.
* @internal
*/
export function convertGeneratedFacetResultToPublic(facetResult) {
const { additionalProperties, ...rest } = facetResult;
return {
...additionalProperties,
...rest,
additionalProperties,
};
}
/**
* Converts a record of FacetResult arrays from generated to public format.
* @internal
*/
export function convertGeneratedFacetsToPublic(facets) {
if (!facets) {
return facets;
}
const result = {};
for (const [key, value] of Object.entries(facets)) {
result[key] = value.map(convertGeneratedFacetResultToPublic);
}
return result;
}
/**
* Converts a generated QueryAnswerResult to a public QueryAnswerResult with additionalProperties spread
* onto the object for backward compatibility.
* @internal
*/
export function convertGeneratedQueryAnswerResultToPublic(answerResult) {
const { additionalProperties, ...rest } = answerResult;
return {
...additionalProperties,
...rest,
additionalProperties,
};
}
/**
* Converts an array of QueryAnswerResult from generated to public format.
* @internal
*/
export function convertGeneratedAnswersToPublic(answers) {
if (!answers) {
return answers;
}
return answers.map(convertGeneratedQueryAnswerResultToPublic);
}
/**
* Converts a generated QueryCaptionResult to a public QueryCaptionResult with additionalProperties spread
* onto the object for backward compatibility.
* @internal
*/
export function convertGeneratedQueryCaptionResultToPublic(captionResult) {
const { additionalProperties, ...rest } = captionResult;
return {
...additionalProperties,
...rest,
additionalProperties,
};
}
/**
* Converts an array of QueryCaptionResult from generated to public format.
* @internal
*/
export function convertGeneratedCaptionsToPublic(captions) {
if (!captions) {
return captions;
}
return captions.map(convertGeneratedQueryCaptionResultToPublic);
}
//# sourceMappingURL=serviceUtils.js.map