@resistdesign/voltra 3.0.0-alpha.43 → 3.0.0-alpha.44

package/api/ORM/TypeInfoORMService.d.ts

@@ -171,6 +171,64 @@ export type TypeInfoORMIndexingConfig = {
         }) => void;
     };
 };
+/**
+ * Optional field overrides for manual indexing maintenance operations.
+ */
+export type TypeInfoORMManualIndexingConfig = {
+    /**
+     * Explicit full-text field name(s) to target instead of the configured defaults.
+     *
+     * Supply the previous field set when cleaning up after a schema/config change.
+     */
+    fullTextIndexFields?: string | string[];
+};
+/**
+ * Optional field overrides for manual index replacement/reindex operations.
+ */
+export type TypeInfoORMReplaceIndexingConfig = {
+    /**
+     * Full-text field name(s) to remove from the previous snapshot.
+     */
+    previousFullTextIndexFields?: string | string[];
+    /**
+     * Full-text field name(s) to add for the next snapshot.
+     */
+    nextFullTextIndexFields?: string | string[];
+};
+/**
+ * Options for reindexing a stored item from the backing driver.
+ */
+export type TypeInfoORMReindexStoredItemConfig = TypeInfoORMReplaceIndexingConfig & {
+    /**
+     * Optional previous snapshot to remove before indexing the current stored item.
+     */
+    previousItem?: Partial<TypeInfoDataItem>;
+};
+/**
+ * Options for reindexing all currently stored items of a type.
+ */
+export type TypeInfoORMReindexStoredTypeConfig = TypeInfoORMReplaceIndexingConfig & {
+    /**
+     * Maximum number of items to load per driver page.
+     */
+    itemsPerPage?: number;
+    /**
+     * Optional previous snapshots keyed by primary field value.
+     *
+     * Use this when a schema/config change requires cleanup of previously indexed
+     * full-text fields before the current item is reindexed.
+     */
+    previousItemsByPrimaryField?: Record<string, Partial<TypeInfoDataItem>>;
+};
+/**
+ * Results from reindexing all currently stored items of a type.
+ */
+export type TypeInfoORMReindexStoredTypeResults = {
+    /**
+     * Number of stored items that were reindexed.
+     */
+    processedCount: number;
+};
 /**
  * The basis for the configuration for the TypeInfoORMService.
  * */
@@ -350,7 +408,7 @@ export declare class TypeInfoORMService implements TypeInfoORMAPI {
     /**
      * Optional override for the index field.
      */
-    override?: string) => string[];
+    override?: string | string[]) => string[];
     /**
      * @returns True when the operator maps to full-text search.
      */
@@ -480,6 +538,18 @@ export declare class TypeInfoORMService implements TypeInfoORMAPI {
      * Item to extract structured fields from.
      */
     item: Partial<TypeInfoDataItem>) => StructuredDocFieldsRecord;
+    /**
+     * @returns Item snapshot normalized for indexing operations.
+     */
+    protected getIndexedItemSnapshot: (
+    /**
+     * Type name used to clean the item.
+     */
+    typeName: string, 
+    /**
+     * Item snapshot to normalize.
+     */
+    item: Partial<TypeInfoDataItem>) => Partial<TypeInfoDataItem>;
     /**
      * @returns Mapped structured query.
      */
@@ -511,7 +581,7 @@ export declare class TypeInfoORMService implements TypeInfoORMAPI {
     /**
      * Optional override for the index field.
      */
-    indexFieldOverride?: string): Promise<void>;
+    indexFieldOverride?: string | string[]): Promise<void>;
     /**
      * @returns Promise resolved once removal is complete.
      */
@@ -527,7 +597,7 @@ export declare class TypeInfoORMService implements TypeInfoORMAPI {
     /**
      * Optional override for the index field.
      */
-    indexFieldOverride?: string): Promise<void>;
+    indexFieldOverride?: string | string[]): Promise<void>;
     /**
      * @returns Promise resolved once replacement is complete.
      */
@@ -547,7 +617,71 @@ export declare class TypeInfoORMService implements TypeInfoORMAPI {
     /**
      * Optional override for the index field.
      */
-    indexFieldOverride?: string): Promise<void>;
+    indexFieldOverride?: string | string[]): Promise<void>;
+    /**
+     * Write the provided item snapshot into the configured indexes.
+     *
+     * Use this when data was created or modified outside `TypeInfoORMService`.
+     *
+     * @param typeName Type name for the indexed item.
+     * @param item Item snapshot to index.
+     * @param config Optional full-text field overrides.
+     * @returns Promise resolved when manual indexing completes.
+     */
+    indexItemIndexes: (typeName: string, item: Partial<TypeInfoDataItem>, config?: TypeInfoORMManualIndexingConfig) => Promise<void>;
+    /**
+     * Remove the provided item snapshot from the configured indexes.
+     *
+     * Use this when data was deleted outside `TypeInfoORMService`.
+     *
+     * @param typeName Type name for the indexed item.
+     * @param item Item snapshot to remove from the indexes.
+     * @param config Optional full-text field overrides.
+     * @returns Promise resolved when index cleanup completes.
+     */
+    removeItemIndexes: (typeName: string, item: Partial<TypeInfoDataItem>, config?: TypeInfoORMManualIndexingConfig) => Promise<void>;
+    /**
+     * Replace one indexed item snapshot with another.
+     *
+     * Use this when an existing stored item changed outside `TypeInfoORMService`
+     * or when a schema/config change requires removing old full-text fields and
+     * indexing a new field set.
+     *
+     * @param typeName Type name for the indexed item.
+     * @param previousItem Previous item snapshot to remove.
+     * @param nextItem Next item snapshot to index.
+     * @param config Optional previous/next full-text field overrides.
+     * @returns Promise resolved when replacement indexing completes.
+     */
+    replaceItemIndexes: (typeName: string, previousItem: Partial<TypeInfoDataItem>, nextItem: Partial<TypeInfoDataItem>, config?: TypeInfoORMReplaceIndexingConfig) => Promise<void>;
+    /**
+     * Reindex the current stored item using the configured driver.
+     *
+     * When no previous snapshot is supplied, the current stored item is used for
+     * both removal and indexing to refresh existing postings without duplication.
+     * Supply `previousItem` when an out-of-band update changed indexed field
+     * values, otherwise old full-text tokens cannot be removed safely.
+     *
+     * @param typeName Type name to reindex.
+     * @param primaryFieldValue Primary field value for the stored item.
+     * @param config Optional previous snapshot and full-text field overrides.
+     * @returns True when reindexing completed.
+     */
+    reindexStoredItem: (typeName: string, primaryFieldValue: LiteralValue, config?: TypeInfoORMReindexStoredItemConfig) => Promise<boolean>;
+    /**
+     * Reindex all currently stored items for a type.
+     *
+     * This is intended for maintenance passes after out-of-band writes or
+     * schema/index configuration changes. Deleted items still require explicit
+     * cleanup via {@link removeItemIndexes}, because full-text token removal
+     * needs a prior snapshot of indexed field values. For out-of-band updates
+     * that changed indexed values, provide `previousItemsByPrimaryField`.
+     *
+     * @param typeName Type name to reindex.
+     * @param config Paging, previous snapshots, and full-text field overrides.
+     * @returns Count of processed stored items.
+     */
+    reindexStoredType: (typeName: string, config?: TypeInfoORMReindexStoredTypeConfig) => Promise<TypeInfoORMReindexStoredTypeResults>;
     /**
      * @returns Promise resolved once indexing is complete.
      */

package/api/ORM/getTypeInfoORMIndexingConfigFromTypeInfoMap.d.ts

@@ -0,0 +1,31 @@
+import type { TypeInfoMap } from "../../common/TypeParsing/TypeInfo";
+import type { TypeInfoORMIndexingConfig } from "./TypeInfoORMService";
+/**
+ * Base indexing config accepted by {@link getTypeInfoORMIndexingConfigFromTypeInfoMap}.
+ *
+ * The utility derives only field lists from `TypeInfo` tags. Concrete backends,
+ * readers, writers, and other runtime dependencies must be supplied here when
+ * a tagged field requires that indexing mode.
+ */
+export type TypeInfoORMIndexingConfigSeed = Omit<TypeInfoORMIndexingConfig, "fullText" | "structured"> & {
+    /**
+     * Optional full-text runtime dependencies and existing field map.
+     */
+    fullText?: TypeInfoORMIndexingConfig["fullText"];
+    /**
+     * Optional structured runtime dependencies and existing field map.
+     */
+    structured?: TypeInfoORMIndexingConfig["structured"];
+};
+/**
+ * Derive ORM indexing field configuration from `TypeInfoField.tags.indexed`.
+ *
+ * The returned config preserves the supplied runtime dependencies and merges
+ * any generated field names into existing `fullText.defaultIndexFieldByType`
+ * and `structured.indexedFieldsByType` entries.
+ *
+ * @param typeInfoMap Type definitions to scan for indexing tags.
+ * @param baseConfig Runtime indexing dependencies and any existing field lists.
+ * @returns ORM indexing config with generated field lists merged in.
+ */
+export declare const getTypeInfoORMIndexingConfigFromTypeInfoMap: (typeInfoMap: TypeInfoMap, baseConfig?: TypeInfoORMIndexingConfigSeed) => TypeInfoORMIndexingConfig;

package/api/ORM/index.d.ts

@@ -4,6 +4,7 @@
 export * from "./drivers";
 export * from "./TypeInfoORMService";
 export * from "./DACUtils";
+export * from "./getTypeInfoORMIndexingConfigFromTypeInfoMap";
 export * from "./ORMRouteMap";
 export * from "../DataAccessControl";
 export * from "../Router/Types";

package/api/index.js

@@ -7528,8 +7528,24 @@ var TypeInfoORMService = class {
    * @returns Resolved full-text index field names.
    */
   resolveFullTextIndexFields = (typeName, override) => {
-    if (override) {
-      return [override];
+    if (typeof override === "string") {
+      return this.resolveFullTextIndexFields(typeName, [override]);
+    }
+    if (Array.isArray(override)) {
+      const seen2 = /* @__PURE__ */ new Set();
+      const fields2 = [];
+      for (const field of override) {
+        if (typeof field !== "string") {
+          continue;
+        }
+        const trimmed = field.trim();
+        if (!trimmed || seen2.has(trimmed)) {
+          continue;
+        }
+        seen2.add(trimmed);
+        fields2.push(trimmed);
+      }
+      return fields2;
     }
     const defaults = this.config.indexing?.fullText?.defaultIndexFieldByType?.[typeName];
     if (typeof defaults === "string") {
@@ -7833,6 +7849,10 @@ var TypeInfoORMService = class {
     }
     return fields;
   };
+  /**
+   * @returns Item snapshot normalized for indexing operations.
+   */
+  getIndexedItemSnapshot = (typeName, item) => this.getCleanItem(typeName, item, {});
   /**
    * @returns Mapped structured query.
    */
@@ -7952,6 +7972,132 @@ var TypeInfoORMService = class {
       });
     }
   }
+  /**
+   * Write the provided item snapshot into the configured indexes.
+   *
+   * Use this when data was created or modified outside `TypeInfoORMService`.
+   *
+   * @param typeName Type name for the indexed item.
+   * @param item Item snapshot to index.
+   * @param config Optional full-text field overrides.
+   * @returns Promise resolved when manual indexing completes.
+   */
+  indexItemIndexes = async (typeName, item, config = {}) => {
+    const indexedItem = this.getIndexedItemSnapshot(typeName, item);
+    await this.indexFullTextDocument(
+      typeName,
+      indexedItem,
+      config.fullTextIndexFields
+    );
+    await this.indexStructuredDocument(typeName, indexedItem);
+  };
+  /**
+   * Remove the provided item snapshot from the configured indexes.
+   *
+   * Use this when data was deleted outside `TypeInfoORMService`.
+   *
+   * @param typeName Type name for the indexed item.
+   * @param item Item snapshot to remove from the indexes.
+   * @param config Optional full-text field overrides.
+   * @returns Promise resolved when index cleanup completes.
+   */
+  removeItemIndexes = async (typeName, item, config = {}) => {
+    const indexedItem = this.getIndexedItemSnapshot(typeName, item);
+    await this.removeFullTextDocument(
+      typeName,
+      indexedItem,
+      config.fullTextIndexFields
+    );
+    await this.removeStructuredDocument(typeName, indexedItem);
+  };
+  /**
+   * Replace one indexed item snapshot with another.
+   *
+   * Use this when an existing stored item changed outside `TypeInfoORMService`
+   * or when a schema/config change requires removing old full-text fields and
+   * indexing a new field set.
+   *
+   * @param typeName Type name for the indexed item.
+   * @param previousItem Previous item snapshot to remove.
+   * @param nextItem Next item snapshot to index.
+   * @param config Optional previous/next full-text field overrides.
+   * @returns Promise resolved when replacement indexing completes.
+   */
+  replaceItemIndexes = async (typeName, previousItem, nextItem, config = {}) => {
+    const previousIndexedItem = this.getIndexedItemSnapshot(typeName, previousItem);
+    const nextIndexedItem = this.getIndexedItemSnapshot(typeName, nextItem);
+    await this.removeFullTextDocument(
+      typeName,
+      previousIndexedItem,
+      config.previousFullTextIndexFields
+    );
+    await this.indexFullTextDocument(
+      typeName,
+      nextIndexedItem,
+      config.nextFullTextIndexFields
+    );
+    await this.indexStructuredDocument(typeName, nextIndexedItem);
+  };
+  /**
+   * Reindex the current stored item using the configured driver.
+   *
+   * When no previous snapshot is supplied, the current stored item is used for
+   * both removal and indexing to refresh existing postings without duplication.
+   * Supply `previousItem` when an out-of-band update changed indexed field
+   * values, otherwise old full-text tokens cannot be removed safely.
+   *
+   * @param typeName Type name to reindex.
+   * @param primaryFieldValue Primary field value for the stored item.
+   * @param config Optional previous snapshot and full-text field overrides.
+   * @returns True when reindexing completed.
+   */
+  reindexStoredItem = async (typeName, primaryFieldValue, config = {}) => {
+    const driver = this.getDriverInternal(typeName);
+    const currentItem = await driver.readItem(primaryFieldValue);
+    const previousItem = config.previousItem ?? currentItem;
+    await this.replaceItemIndexes(typeName, previousItem, currentItem, {
+      previousFullTextIndexFields: config.previousFullTextIndexFields,
+      nextFullTextIndexFields: config.nextFullTextIndexFields
+    });
+    return true;
+  };
+  /**
+   * Reindex all currently stored items for a type.
+   *
+   * This is intended for maintenance passes after out-of-band writes or
+   * schema/index configuration changes. Deleted items still require explicit
+   * cleanup via {@link removeItemIndexes}, because full-text token removal
+   * needs a prior snapshot of indexed field values. For out-of-band updates
+   * that changed indexed values, provide `previousItemsByPrimaryField`.
+   *
+   * @param typeName Type name to reindex.
+   * @param config Paging, previous snapshots, and full-text field overrides.
+   * @returns Count of processed stored items.
+   */
+  reindexStoredType = async (typeName, config = {}) => {
+    const driver = this.getDriverInternal(typeName);
+    const primaryFieldName = String(this.getTypeInfo(typeName).primaryField);
+    const itemsPerPage = config.itemsPerPage ?? 100;
+    let processedCount = 0;
+    let cursor;
+    do {
+      const page = await driver.listItems({ itemsPerPage, cursor });
+      for (const item of page.items) {
+        const primaryFieldValue = item[primaryFieldName];
+        if (typeof primaryFieldValue === "undefined") {
+          continue;
+        }
+        const previousItem = config.previousItemsByPrimaryField?.[String(primaryFieldValue)] ?? item;
+        await this.replaceItemIndexes(typeName, previousItem, item, {
+          previousFullTextIndexFields: config.previousFullTextIndexFields,
+          nextFullTextIndexFields: config.nextFullTextIndexFields
+        });
+        processedCount += 1;
+      }
+      cursor = page.cursor;
+    } while (cursor);
+    return { processedCount };
+  };
   /**
    * @returns Promise resolved once indexing is complete.
    */
@@ -8475,8 +8621,7 @@ var TypeInfoORMService = class {
       ...cleanItem,
       [primaryField]: newIdentifier
     };
-    await this.indexFullTextDocument(typeName, indexedItem);
-    await this.indexStructuredDocument(typeName, indexedItem);
+    await this.indexItemIndexes(typeName, indexedItem);
     return newIdentifier;
   };
   /**
@@ -8619,12 +8764,10 @@ var TypeInfoORMService = class {
         const result = await driver.updateItem(primaryFieldValue, cleanItem);
         const updatedItem = await driver.readItem(primaryFieldValue);
         if (existingItem) {
-          await this.removeFullTextDocument(typeName, existingItem);
-          await this.indexFullTextDocument(typeName, updatedItem);
+          await this.replaceItemIndexes(typeName, existingItem, updatedItem);
         } else {
-          await this.indexFullTextDocument(typeName, updatedItem);
+          await this.indexItemIndexes(typeName, updatedItem);
         }
-        await this.indexStructuredDocument(typeName, updatedItem);
         return result;
       }
     }
@@ -8661,8 +8804,7 @@ var TypeInfoORMService = class {
         fromTypeName: typeName,
         fromTypePrimaryFieldValue: primaryFieldValue
       });
-      await this.removeFullTextDocument(typeName, existingItem);
-      await this.removeStructuredDocument(typeName, existingItem);
+      await this.removeItemIndexes(typeName, existingItem);
       return result;
     }
   };
@@ -8897,6 +9039,100 @@ var TypeInfoORMService = class {
   };
 };
 
+// src/api/ORM/getTypeInfoORMIndexingConfigFromTypeInfoMap.ts
+var dedupeFieldNames = (fieldNames) => {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const fieldName of fieldNames) {
+    if (typeof fieldName !== "string") {
+      continue;
+    }
+    const trimmed = fieldName.trim();
+    if (!trimmed || seen.has(trimmed)) {
+      continue;
+    }
+    seen.add(trimmed);
+    deduped.push(trimmed);
+  }
+  return deduped;
+};
+var normalizeFieldMap = (fieldMap) => {
+  const normalized = {};
+  if (!fieldMap) {
+    return normalized;
+  }
+  for (const [typeName, configuredFieldNames] of Object.entries(fieldMap)) {
+    const values = Array.isArray(configuredFieldNames) ? configuredFieldNames : [configuredFieldNames];
+    const deduped = dedupeFieldNames(values);
+    if (deduped.length > 0) {
+      normalized[typeName] = deduped;
+    }
+  }
+  return normalized;
+};
+var mergeFieldMaps = (existing, generated) => {
+  const merged = { ...existing };
+  for (const [typeName, generatedFieldNames] of Object.entries(generated)) {
+    merged[typeName] = dedupeFieldNames([
+      ...existing[typeName] ?? [],
+      ...generatedFieldNames
+    ]);
+  }
+  return merged;
+};
+var hasIndexedFields = (fieldMap) => Object.keys(fieldMap).length > 0;
+var getTypeInfoORMIndexingConfigFromTypeInfoMap = (typeInfoMap, baseConfig = {}) => {
+  const generatedFullText = {};
+  const generatedStructured = {};
+  for (const [typeName, typeInfo] of Object.entries(typeInfoMap)) {
+    const fields = typeInfo.fields ?? {};
+    for (const [fieldName, field] of Object.entries(fields)) {
+      const indexed = field.tags?.indexed;
+      if (indexed?.fullText) {
+        generatedFullText[typeName] = [
+          ...generatedFullText[typeName] ?? [],
+          fieldName
+        ];
+      }
+      if (indexed?.structured) {
+        generatedStructured[typeName] = [
+          ...generatedStructured[typeName] ?? [],
+          fieldName
+        ];
+      }
+    }
+  }
+  if (hasIndexedFields(generatedFullText) && !baseConfig.fullText?.backend) {
+    throw new Error(
+      "Cannot generate fullText indexing config from tags without fullText.backend."
+    );
+  }
+  if (hasIndexedFields(generatedStructured) && !baseConfig.structured?.reader) {
+    throw new Error(
+      "Cannot generate structured indexing config from tags without structured.reader."
+    );
+  }
+  const mergedFullTextByType = mergeFieldMaps(
+    normalizeFieldMap(baseConfig.fullText?.defaultIndexFieldByType),
+    generatedFullText
+  );
+  const mergedStructuredByType = mergeFieldMaps(
+    normalizeFieldMap(baseConfig.structured?.indexedFieldsByType),
+    generatedStructured
+  );
+  return {
+    ...baseConfig,
+    fullText: baseConfig.fullText ? {
+      ...baseConfig.fullText,
+      ...hasIndexedFields(mergedFullTextByType) ? { defaultIndexFieldByType: mergedFullTextByType } : {}
+    } : void 0,
+    structured: baseConfig.structured ? {
+      ...baseConfig.structured,
+      ...hasIndexedFields(mergedStructuredByType) ? { indexedFieldsByType: mergedStructuredByType } : {}
+    } : void 0
+  };
+};
+
 // src/api/Router/Auth.ts
 var getRouteIsAuthorized = (authInfo, authConfig) => {
   const { userId, roles = [] } = authInfo;
@@ -9302,4 +9538,4 @@ var getContextFromEventData = (eventData, dacConfig, getAccessingRoleId) => {
   return { accessingRoleId };
 };
 
-export { AWS, DACConstraintType, DATA_ITEM_DB_DRIVER_ERRORS, DynamoDBDataItemDBDriver, DynamoDBSupportedDataItemDBDriverEntry, ExactIndex, FullTextDdbBackend, FullTextDdbWriter, FullTextMemoryBackend, InMemoryDataItemDBDriver, InMemoryFileItemDBDriver, InMemoryFileSupportedDataItemDBDriverEntry, InMemoryItemRelationshipDBDriver, InMemorySupportedDataItemDBDriverEntry, IndexingRelationshipDriver, LossyIndex, RelationalDdbBackend, RelationalInMemoryBackend, S3FileItemDBDriver, S3SupportedFileItemDBDriverEntry, SEARCH_CAPS, SEARCH_DEFAULTS, SUPPORTED_TYPE_INFO_ORM_DB_DRIVERS, StructuredDdbBackend, StructuredDdbReader, StructuredDdbWriter, StructuredInMemoryBackend, StructuredInMemoryIndex, SupportedTypeInfoORMDBDriverNames, TYPE_INFO_ORM_API_PATH_METHOD_NAME_MAP, TYPE_INFO_ORM_ROUTE_MAP_ERRORS, TypeInfoORMService, WILDCARD_SIGNIFIER_PROTOTYPE, addRouteMapToRouteMap, addRouteToRouteMap, addRoutesToRouteMap, batchWriteWithRetry, buildExactDdbItem, buildExactDdbKey, buildExactS3Key, buildLossyDdbKey, buildLossyS3Key, buildRelationEdgeDdbItem, buildRelationEdgeDdbKey, buildStructuredDocFieldsItem, buildStructuredRangeItem, buildStructuredRangeKey, buildStructuredTermItem, buildStructuredTermKey, cleanRelationshipItem, createAwsSdkV3DynamoClient, createRelationEdgesDdbDependencies, createSearchTrace, decodeExactCursor, decodeLossyCursor, decodeRelationalCursor, decodeStructuredCursor, docTokenPositionsSchema, docTokensSchema, encodeDocKey, encodeDocMirrorKey, encodeDocTokenPositionSortKey, encodeDocTokenSortKey, encodeExactCursor, encodeLossyCursor, encodeRelationEdgePartitionKey, encodeRelationalCursor, encodeStructuredCursor, encodeTokenDocSortKey, encodeTokenKey, exactDdbSchema, exactPostingsSchema, fullTextDocMirrorSchema, fullTextKeyPrefixes, fullTextTokenStatsSchema, getDACPathsMatch, getDACRoleHasAccessToDataItem, getDataItemDACResourcePath, getDataItemFieldValueDACResourcePath, getDriverMethodWithModifiedError, getFlattenedDACConstraints, getFullORMDACRole, getItemRelationshipDACResourcePath, getItemRelationshipOriginDACConstraint, getItemRelationshipOriginDACResourcePath, getItemRelationshipOriginDACRole, getItemTypeDACConstraint, getItemTypeDACResourcePath, getItemTypeDACRole, getORMDACResourcePath, getResourceAccessByDACRole, getTypeInfoORMRouteMap, getValueIsWildcardSignifier, handleCloudFunctionEvent, handler, indexDocument, loadExactPositions, loadLossyIndex, lossyDdbSchema, lossyPostingsSchema, mergeDACAccessResults, mergeDACDataItemResourceAccessResultMaps, qualifyIndexField, relHandler, relationEdgesSchema, removeDocument, replaceFullTextDocument, resolveSearchLimits, searchExact, searchLossy, searchStructured, serializeStructuredValue, setIndexBackend, setRelationalHandlerDependencies, setStructuredHandlerDependencies, storeExactPositions, storeLossyIndex, structuredDocFieldsSchema, structuredHandler, structuredRangeIndexSchema, structuredTermIndexSchema, tokenize, tokenizeLossyTrigrams };
+export { AWS, DACConstraintType, DATA_ITEM_DB_DRIVER_ERRORS, DynamoDBDataItemDBDriver, DynamoDBSupportedDataItemDBDriverEntry, ExactIndex, FullTextDdbBackend, FullTextDdbWriter, FullTextMemoryBackend, InMemoryDataItemDBDriver, InMemoryFileItemDBDriver, InMemoryFileSupportedDataItemDBDriverEntry, InMemoryItemRelationshipDBDriver, InMemorySupportedDataItemDBDriverEntry, IndexingRelationshipDriver, LossyIndex, RelationalDdbBackend, RelationalInMemoryBackend, S3FileItemDBDriver, S3SupportedFileItemDBDriverEntry, SEARCH_CAPS, SEARCH_DEFAULTS, SUPPORTED_TYPE_INFO_ORM_DB_DRIVERS, StructuredDdbBackend, StructuredDdbReader, StructuredDdbWriter, StructuredInMemoryBackend, StructuredInMemoryIndex, SupportedTypeInfoORMDBDriverNames, TYPE_INFO_ORM_API_PATH_METHOD_NAME_MAP, TYPE_INFO_ORM_ROUTE_MAP_ERRORS, TypeInfoORMService, WILDCARD_SIGNIFIER_PROTOTYPE, addRouteMapToRouteMap, addRouteToRouteMap, addRoutesToRouteMap, batchWriteWithRetry, buildExactDdbItem, buildExactDdbKey, buildExactS3Key, buildLossyDdbKey, buildLossyS3Key, buildRelationEdgeDdbItem, buildRelationEdgeDdbKey, buildStructuredDocFieldsItem, buildStructuredRangeItem, buildStructuredRangeKey, buildStructuredTermItem, buildStructuredTermKey, cleanRelationshipItem, createAwsSdkV3DynamoClient, createRelationEdgesDdbDependencies, createSearchTrace, decodeExactCursor, decodeLossyCursor, decodeRelationalCursor, decodeStructuredCursor, docTokenPositionsSchema, docTokensSchema, encodeDocKey, encodeDocMirrorKey, encodeDocTokenPositionSortKey, encodeDocTokenSortKey, encodeExactCursor, encodeLossyCursor, encodeRelationEdgePartitionKey, encodeRelationalCursor, encodeStructuredCursor, encodeTokenDocSortKey, encodeTokenKey, exactDdbSchema, exactPostingsSchema, fullTextDocMirrorSchema, fullTextKeyPrefixes, fullTextTokenStatsSchema, getDACPathsMatch, getDACRoleHasAccessToDataItem, getDataItemDACResourcePath, getDataItemFieldValueDACResourcePath, getDriverMethodWithModifiedError, getFlattenedDACConstraints, getFullORMDACRole, getItemRelationshipDACResourcePath, getItemRelationshipOriginDACConstraint, getItemRelationshipOriginDACResourcePath, getItemRelationshipOriginDACRole, getItemTypeDACConstraint, getItemTypeDACResourcePath, getItemTypeDACRole, getORMDACResourcePath, getResourceAccessByDACRole, getTypeInfoORMIndexingConfigFromTypeInfoMap, getTypeInfoORMRouteMap, getValueIsWildcardSignifier, handleCloudFunctionEvent, handler, indexDocument, loadExactPositions, loadLossyIndex, lossyDdbSchema, lossyPostingsSchema, mergeDACAccessResults, mergeDACDataItemResourceAccessResultMaps, qualifyIndexField, relHandler, relationEdgesSchema, removeDocument, replaceFullTextDocument, resolveSearchLimits, searchExact, searchLossy, searchStructured, serializeStructuredValue, setIndexBackend, setRelationalHandlerDependencies, setStructuredHandlerDependencies, storeExactPositions, storeLossyIndex, structuredDocFieldsSchema, structuredHandler, structuredRangeIndexSchema, structuredTermIndexSchema, tokenize, tokenizeLossyTrigrams };

package/common/TypeParsing/TypeInfo.d.ts

@@ -132,6 +132,19 @@ export type SupportedFieldTags = Partial<{
          */
         emptyArrayIsValid: boolean;
     }>;
+    /**
+     * Indexing behavior flags used to derive ORM indexing configuration.
+     * */
+    indexed: Partial<{
+        /**
+         * Whether this field should be added to the type's default full-text index fields.
+         * */
+        fullText: boolean;
+        /**
+         * Whether this field should be added to the type's structured indexed field list.
+         * */
+        structured: boolean;
+    }>;
 }>;
 /**
  * The set of acceptable literal value types.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resistdesign/voltra",
-  "version": "3.0.0-alpha.43",
+  "version": "3.0.0-alpha.44",
   "description": "With our powers combined!",
   "homepage": "https://voltra.app",
   "repository": "git@github.com:resistdesign/voltra.git",