document-dataply 0.0.8 → 0.0.9-alpha.1

package/dist/types/core/bptree/documentStrategy.d.ts

@@ -2,10 +2,10 @@ import type { DataplyTreeValue, Primitive } from '../../types';
 import { BPTreeNode, SerializeStrategyAsync, type SerializeStrategyHead } from 'dataply';
 import { DocumentDataplyAPI } from '../documentAPI';
 export declare class DocumentSerializeStrategyAsync<T extends Primitive> extends SerializeStrategyAsync<number, DataplyTreeValue<T>> {
-    protected readonly api: DocumentDataplyAPI<any, any>;
-    protected readonly txContext: DocumentDataplyAPI<any, any>['txContext'];
+    protected readonly api: DocumentDataplyAPI<any>;
+    protected readonly txContext: DocumentDataplyAPI<any>['txContext'];
     readonly treeKey: string;
-    constructor(order: number, api: DocumentDataplyAPI<any, any>, txContext: DocumentDataplyAPI<any, any>['txContext'], treeKey: string);
+    constructor(order: number, api: DocumentDataplyAPI<any>, txContext: DocumentDataplyAPI<any>['txContext'], treeKey: string);
     id(isLeaf: boolean): Promise<string>;
     read(id: string): Promise<BPTreeNode<number, DataplyTreeValue<T>>>;
     write(id: string, node: BPTreeNode<number, DataplyTreeValue<T>>): Promise<void>;

package/dist/types/core/document.d.ts

@@ -1,7 +1,7 @@
-import type { DocumentDataplyOptions, DocumentJSON, DocumentDataplyIndexedQuery, DataplyDocument, DocumentDataplyMetadata, DocumentDataplyQueryOptions, IndexConfig } from '../types';
+import type { DocumentDataplyOptions, DocumentJSON, DocumentDataplyQuery, DataplyDocument, DocumentDataplyMetadata, DocumentDataplyQueryOptions, CreateIndexOption } from '../types';
 import { Transaction } from 'dataply';
 import { DocumentDataplyAPI } from './documentAPI';
-export declare class DocumentDataply<T extends DocumentJSON, IC extends IndexConfig<T>> {
+export declare class DocumentDataply<T extends DocumentJSON> {
     /**
      * Starts the database definition by setting the document type.
      * This is used to ensure TypeScript type inference works correctly for the document structure.
@@ -9,16 +9,15 @@ export declare class DocumentDataply<T extends DocumentJSON, IC extends IndexCon
      */
     static Define<T extends DocumentJSON>(): {
         /**
-         * Sets the options for the database, such as index configurations and WAL settings.
-         * @template IC The configuration of indices.
+         * Sets the options for the database, such as WAL settings.
          * @param options The database initialization options.
          */
-        Options: <IC extends IndexConfig<T>>(options: DocumentDataplyOptions<T, IC>) => {
+        Options: (options: DocumentDataplyOptions) => {
             /**
              * Creates or opens the database instance with the specified file path.
              * @param file The path to the database file.
              */
-            Open: (file: string) => DocumentDataply<T, IC>;
+            Open: (file: string) => DocumentDataply<T>;
         };
     };
     /**
@@ -29,12 +28,39 @@ export declare class DocumentDataply<T extends DocumentJSON, IC extends IndexCon
      * Internal method used to finalize construction and create the instance.
      */
     private static Open;
-    protected readonly api: DocumentDataplyAPI<T, IC>;
-    protected constructor(file: string, options?: DocumentDataplyOptions<T, IC>);
+    protected readonly api: DocumentDataplyAPI<T>;
+    protected constructor(file: string, options?: DocumentDataplyOptions);
+    /**
+     * Create a named index on the database.
+     * Can be called before or after init().
+     * If called after init(), the index is immediately created and backfilled.
+     * @param name The name of the index
+     * @param option The index configuration (btree or fts)
+     * @param tx Optional transaction
+     * @returns Promise<this> for chaining
+     */
+    createIndex(name: string, option: CreateIndexOption<T>, tx?: Transaction): Promise<this>;
+    /**
+     * Drop (remove) a named index from the database.
+     * The '_id' index cannot be dropped.
+     * @param name The name of the index to drop
+     * @param tx Optional transaction
+     * @returns Promise<this> for chaining
+     */
+    dropIndex(name: string, tx?: Transaction): Promise<this>;
     /**
      * Initialize the document database
      */
     init(): Promise<void>;
+    /**
+     * Run a migration if the current schemeVersion is lower than the target version.
+     * The callback is only executed when the database's schemeVersion is below the given version.
+     * After the callback completes, schemeVersion is updated to the target version.
+     * @param version The target scheme version
+     * @param callback The migration callback receiving a transaction
+     * @param tx Optional transaction
+     */
+    migration(version: number, callback: (tx: Transaction) => Promise<void>, tx?: Transaction): Promise<void>;
     /**
      * Get the metadata of the document database
      */
@@ -59,43 +85,43 @@ export declare class DocumentDataply<T extends DocumentJSON, IC extends IndexCon
     insertBatch(documents: T[], tx?: Transaction): Promise<number[]>;
     /**
      * Fully update documents from the database that match the query
-     * @param query The query to use (only indexed fields + _id allowed)
+     * @param query The query to use
      * @param newRecord Complete document to replace with, or function that receives current document and returns new document
      * @param tx The transaction to use
      * @returns The number of updated documents
      */
-    fullUpdate(query: Partial<DocumentDataplyIndexedQuery<T, IC>>, newRecord: T | ((document: DataplyDocument<T>) => T), tx?: Transaction): Promise<number>;
+    fullUpdate(query: Partial<DocumentDataplyQuery<T>>, newRecord: T | ((document: DataplyDocument<T>) => T), tx?: Transaction): Promise<number>;
     /**
      * Partially update documents from the database that match the query
-     * @param query The query to use (only indexed fields + _id allowed)
+     * @param query The query to use
      * @param newRecord Partial document to merge, or function that receives current document and returns partial update
      * @param tx The transaction to use
      * @returns The number of updated documents
      */
-    partialUpdate(query: Partial<DocumentDataplyIndexedQuery<T, IC>>, newRecord: Partial<DataplyDocument<T>> | ((document: DataplyDocument<T>) => Partial<DataplyDocument<T>>), tx?: Transaction): Promise<number>;
+    partialUpdate(query: Partial<DocumentDataplyQuery<T>>, newRecord: Partial<DataplyDocument<T>> | ((document: DataplyDocument<T>) => Partial<DataplyDocument<T>>), tx?: Transaction): Promise<number>;
     /**
      * Delete documents from the database that match the query
-     * @param query The query to use (only indexed fields + _id allowed)
+     * @param query The query to use
      * @param tx The transaction to use
      * @returns The number of deleted documents
      */
-    delete(query: Partial<DocumentDataplyIndexedQuery<T, IC>>, tx?: Transaction): Promise<number>;
+    delete(query: Partial<DocumentDataplyQuery<T>>, tx?: Transaction): Promise<number>;
     /**
      * Count documents from the database that match the query
-     * @param query The query to use (only indexed fields + _id allowed)
+     * @param query The query to use
      * @param tx The transaction to use
      * @returns The number of documents that match the query
      */
-    count(query: Partial<DocumentDataplyIndexedQuery<T, IC>>, tx?: Transaction): Promise<number>;
+    count(query: Partial<DocumentDataplyQuery<T>>, tx?: Transaction): Promise<number>;
     /**
      * Select documents from the database
-     * @param query The query to use (only indexed fields + _id allowed)
+     * @param query The query to use
      * @param options The options to use
      * @param tx The transaction to use
      * @returns The documents that match the query
      * @throws Error if query or orderBy contains non-indexed fields
      */
-    select(query: Partial<DocumentDataplyIndexedQuery<T, IC>>, options?: DocumentDataplyQueryOptions<T, IC>, tx?: Transaction): {
+    select(query: Partial<DocumentDataplyQuery<T>>, options?: DocumentDataplyQueryOptions, tx?: Transaction): {
         stream: AsyncIterableIterator<DataplyDocument<T>>;
         drain: () => Promise<DataplyDocument<T>[]>;
     };

package/dist/types/core/documentAPI.d.ts

@@ -1,7 +1,7 @@
-import type { DataplyTreeValue, DocumentDataplyInnerMetadata, DocumentDataplyOptions, DocumentJSON, FlattenedDocumentJSON, Primitive, DataplyDocument, DocumentDataplyMetadata, IndexConfig, DocumentDataplyQuery, DocumentDataplyIndexedQuery, DocumentDataplyCondition, DocumentDataplyQueryOptions } from '../types';
+import type { DataplyTreeValue, DocumentDataplyInnerMetadata, DocumentDataplyOptions, DocumentJSON, FlattenedDocumentJSON, Primitive, DataplyDocument, DocumentDataplyMetadata, DocumentDataplyQuery, DocumentDataplyCondition, DocumentDataplyQueryOptions, CreateIndexOption } from '../types';
 import { DataplyAPI, Transaction, BPTreeAsync } from 'dataply';
 import { DocumentValueComparator } from './bptree/documentComparator';
-export declare class DocumentDataplyAPI<T extends DocumentJSON, IC extends IndexConfig<T>> extends DataplyAPI {
+export declare class DocumentDataplyAPI<T extends DocumentJSON> extends DataplyAPI {
     runWithDefault: <T_1>(callback: (tx: Transaction) => Promise<T_1>, tx?: Transaction) => Promise<T_1>;
     streamWithDefault: <T_1>(callback: (tx: Transaction) => AsyncGenerator<T_1>, tx?: Transaction) => AsyncGenerator<T_1>;
     indices: DocumentDataplyInnerMetadata['indices'];
@@ -9,16 +9,78 @@ export declare class DocumentDataplyAPI<T extends DocumentJSON, IC extends Index
     readonly comparator: DocumentValueComparator<DataplyTreeValue<Primitive>, Primitive>;
     private pendingBackfillFields;
     private readonly lock;
+    private _initialized;
     readonly indexedFields: Set<string>;
+    /**
+     * Registered indices via createIndex() (before init)
+     * Key: index name, Value: index configuration
+     */
+    private readonly pendingCreateIndices;
+    /**
+     * Resolved index configurations after init.
+     * Key: index name, Value: index config (from metadata)
+     */
+    private registeredIndices;
+    /**
+     * Maps field name → index names that cover this field.
+     * Used for query resolution.
+     */
+    private fieldToIndices;
     private readonly operatorConverters;
-    constructor(file: string, options: DocumentDataplyOptions<T, IC>);
+    constructor(file: string, options: DocumentDataplyOptions);
+    /**
+     * Whether the document database has been initialized.
+     */
+    get isDocInitialized(): boolean;
+    /**
+     * Register an index. If called before init(), queues it for processing during init.
+     * If called after init(), immediately creates the tree, updates metadata, and backfills.
+     */
+    registerIndex(name: string, option: CreateIndexOption<T>, tx?: Transaction): Promise<void>;
+    /**
+     * Register an index at runtime (after init).
+     * Creates the tree, updates metadata, and backfills existing data.
+     */
+    private registerIndexRuntime;
+    /**
+     * Drop (remove) a named index.
+     * Removes the index from metadata, in-memory maps, and trees.
+     * The '_id' index cannot be dropped.
+     * @param name The name of the index to drop
+     */
+    dropIndex(name: string, tx?: Transaction): Promise<void>;
+    /**
+     * Convert CreateIndexOption to IndexMetaConfig for metadata storage.
+     */
+    private toIndexMetaConfig;
+    /**
+     * Get all field names from an IndexMetaConfig.
+     */
+    private getFieldsFromConfig;
+    /**
+     * Get the primary field of an index (the field used as tree key).
+     * For btree: first field in fields array.
+     * For fts: the single field.
+     */
+    private getPrimaryField;
+    /**
+     * 인덱스 config에 따라 B+tree에 저장할 v 값을 생성합니다.
+     * - 단일 필드 btree: Primitive (단일 값)
+     * - 복합 필드 btree: Primitive[] (필드 순서대로 배열)
+     * - fts: 별도 처리 (이 메서드 사용 안 함)
+     * @returns undefined면 해당 문서에 필수 필드가 없으므로 인덱싱 스킵
+     */
+    private getIndexValue;
+    /**
+     * Get FTSConfig from IndexMetaConfig (for tokenizer compatibility).
+     */
+    private getFtsConfig;
     getDocument(pk: number, tx?: Transaction): Promise<DataplyDocument<T>>;
     readLock<T>(fn: () => T): Promise<T>;
     writeLock<T>(fn: () => T): Promise<T>;
     /**
-     * Backfill indices for fields that were added with `true` option after data was inserted.
-     * This method should be called after `init()` if you want to index existing documents
-     * for newly added index fields.
+     * Backfill indices for newly created indices after data was inserted.
+     * This method should be called after `init()`.
      *
      * @returns Number of documents that were backfilled
      */
@@ -36,28 +98,40 @@ export declare class DocumentDataplyAPI<T extends DocumentJSON, IC extends Index
     getDocumentMetadata(tx: Transaction): Promise<DocumentDataplyMetadata>;
     getDocumentInnerMetadata(tx: Transaction): Promise<DocumentDataplyInnerMetadata>;
     updateDocumentInnerMetadata(metadata: DocumentDataplyInnerMetadata, tx: Transaction): Promise<void>;
+    /**
+     * Run a migration if the current schemeVersion is lower than the target version.
+     * After the callback completes, schemeVersion is updated to the target version.
+     * @param version The target scheme version
+     * @param callback The migration callback
+     * @param tx Optional transaction
+     */
+    migration(version: number, callback: (tx: Transaction) => Promise<void>, tx?: Transaction): Promise<void>;
     /**
      * Transforms a query object into a verbose query object
      * @param query The query object to transform
      * @returns The verbose query object
      */
-    verboseQuery<U extends Partial<DocumentDataplyIndexedQuery<T, IC>>, V extends DataplyTreeValue<U>>(query: Partial<DocumentDataplyQuery<U>>): Partial<DocumentDataplyQuery<V>>;
+    verboseQuery<U extends Partial<DocumentDataplyQuery<T>>, V extends DataplyTreeValue<U>>(query: Partial<DocumentDataplyQuery<U>>): Partial<DocumentDataplyQuery<V>>;
     /**
-     * Get the selectivity candidate for the given query
-     * @param query The query conditions
+     * Choose the best index (driver) for the given query.
+     * Scores each index based on field coverage and condition type.
+     *
+     * @param query The verbose query conditions
      * @param orderByField Optional field name for orderBy optimization
      * @returns Driver and other candidates for query execution
      */
-    getSelectivityCandidate<U extends Partial<DocumentDataplyIndexedQuery<T, IC>>, V extends DataplyTreeValue<U>>(query: Partial<DocumentDataplyQuery<V>>, orderByField?: string): Promise<{
+    getSelectivityCandidate<U extends Partial<DocumentDataplyQuery<T>>, V extends DataplyTreeValue<U>>(query: Partial<DocumentDataplyQuery<V>>, orderByField?: string): Promise<{
         driver: ({
             tree: BPTreeAsync<number, V>;
             condition: Partial<DocumentDataplyCondition<U>>;
             field: string;
+            indexName: string;
             isFtsMatch: false;
         } | {
             tree: BPTreeAsync<string, V>;
             condition: Partial<DocumentDataplyCondition<U>>;
             field: string;
+            indexName: string;
             isFtsMatch: true;
             matchTokens: string[];
         });
@@ -65,14 +139,20 @@ export declare class DocumentDataplyAPI<T extends DocumentJSON, IC extends Index
             tree: BPTreeAsync<number, V>;
             condition: Partial<DocumentDataplyCondition<U>>;
             field: string;
+            indexName: string;
             isFtsMatch: false;
         } | {
             tree: BPTreeAsync<string, V>;
             condition: Partial<DocumentDataplyCondition<U>>;
             field: string;
+            indexName: string;
             isFtsMatch: true;
             matchTokens: string[];
         })[];
+        compositeVerifyConditions: {
+            field: string;
+            condition: any;
+        }[];
         rollback: () => void;
     } | null>;
     /**
@@ -93,7 +173,7 @@ export declare class DocumentDataplyAPI<T extends DocumentJSON, IC extends Index
      * 쿼리와 인덱스 선택을 기반으로 기본 키(Primary Keys)를 가져옵니다.
      * 쿼리 최적화를 통합하기 위한 내부 공통 메서드입니다.
      */
-    getKeys(query: Partial<DocumentDataplyIndexedQuery<T, IC>>, orderBy?: keyof IC | '_id', sortOrder?: 'asc' | 'desc'): Promise<Float64Array>;
+    getKeys(query: Partial<DocumentDataplyQuery<T>>, orderBy?: string, sortOrder?: 'asc' | 'desc'): Promise<Float64Array>;
     /**
      * 드라이버 인덱스만으로 PK를 가져옵니다. (교집합 없이)
      * selectDocuments에서 사용하며, 나머지 조건(others)은 스트리밍 중 tree.verify()로 검증합니다.
@@ -125,57 +205,64 @@ export declare class DocumentDataplyAPI<T extends DocumentJSON, IC extends Index
     private updateInternal;
     /**
      * Fully update documents from the database that match the query
-     * @param query The query to use (only indexed fields + _id allowed)
+     * @param query The query to use
      * @param newRecord Complete document to replace with, or function that receives current document and returns new document
      * @param tx The transaction to use
      * @returns The number of updated documents
      */
-    fullUpdate(query: Partial<DocumentDataplyIndexedQuery<T, IC>>, newRecord: T | ((document: DataplyDocument<T>) => T), tx?: Transaction): Promise<number>;
+    fullUpdate(query: Partial<DocumentDataplyQuery<T>>, newRecord: T | ((document: DataplyDocument<T>) => T), tx?: Transaction): Promise<number>;
     /**
      * Partially update documents from the database that match the query
-     * @param query The query to use (only indexed fields + _id allowed)
+     * @param query The query to use
      * @param newRecord Partial document to merge, or function that receives current document and returns partial update
      * @param tx The transaction to use
      * @returns The number of updated documents
      */
-    partialUpdate(query: Partial<DocumentDataplyIndexedQuery<T, IC>>, newRecord: Partial<DataplyDocument<T>> | ((document: DataplyDocument<T>) => Partial<DataplyDocument<T>>), tx?: Transaction): Promise<number>;
+    partialUpdate(query: Partial<DocumentDataplyQuery<T>>, newRecord: Partial<DataplyDocument<T>> | ((document: DataplyDocument<T>) => Partial<DataplyDocument<T>>), tx?: Transaction): Promise<number>;
     /**
      * Delete documents from the database that match the query
-     * @param query The query to use (only indexed fields + _id allowed)
+     * @param query The query to use
      * @param tx The transaction to use
      * @returns The number of deleted documents
      */
-    deleteDocuments(query: Partial<DocumentDataplyIndexedQuery<T, IC>>, tx?: Transaction): Promise<number>;
+    deleteDocuments(query: Partial<DocumentDataplyQuery<T>>, tx?: Transaction): Promise<number>;
     /**
      * Count documents from the database that match the query
-     * @param query The query to use (only indexed fields + _id allowed)
+     * @param query The query to use
      * @param tx The transaction to use
      * @returns The number of documents that match the query
      */
-    countDocuments(query: Partial<DocumentDataplyIndexedQuery<T, IC>>, tx?: Transaction): Promise<number>;
+    countDocuments(query: Partial<DocumentDataplyQuery<T>>, tx?: Transaction): Promise<number>;
     /**
      * FTS 조건에 대해 문서가 유효한지 검증합니다.
      */
     private verifyFts;
+    /**
+     * 복합 인덱스의 non-primary 필드에 대해 문서가 유효한지 검증합니다.
+     */
+    private verifyCompositeConditions;
+    /**
+     * 단일 값에 대해 verbose 조건을 검증합니다.
+     */
+    private verifyValue;
     /**
      * 메모리 기반으로 청크 크기를 동적 조절합니다.
      */
     private adjustChunkSize;
     /**
      * Prefetch 방식으로 키 배열을 청크 단위로 조회하여 문서를 순회합니다.
-     * FTS 검증 및 others 후보에 대한 tree.verify() 검증을 통과한 문서만 yield 합니다.
-     * 교집합 대신 스트리밍 중 검증하여 첫 결과 반환 시간을 단축합니다.
+     * FTS 검증, 복합 인덱스 검증, others 후보에 대한 tree.verify() 검증을 통과한 문서만 yield 합니다.
      */
     private processChunkedKeysWithVerify;
     /**
      * Select documents from the database
-     * @param query The query to use (only indexed fields + _id allowed)
+     * @param query The query to use
      * @param options The options to use
      * @param tx The transaction to use
      * @returns The documents that match the query
      * @throws Error if query or orderBy contains non-indexed fields
      */
-    selectDocuments(query: Partial<DocumentDataplyIndexedQuery<T, IC>>, options?: DocumentDataplyQueryOptions<T, IC>, tx?: Transaction): {
+    selectDocuments(query: Partial<DocumentDataplyQuery<T>>, options?: DocumentDataplyQueryOptions, tx?: Transaction): {
         stream: AsyncIterableIterator<DataplyDocument<T>>;
         drain: () => Promise<DataplyDocument<T>[]>;
     };

package/dist/types/types/index.d.ts

@@ -9,23 +9,34 @@ export type DocumentJSON = {
 export type FlattenedDocumentJSON = {
     [key: string]: Primitive;
 };
+/**
+ * Index metadata config stored in DB metadata.
+ * Used internally to persist index configuration.
+ */
+export type IndexMetaConfig = {
+    type: 'btree';
+    fields: string[];
+} | {
+    type: 'fts';
+    fields: string;
+    tokenizer: 'whitespace';
+} | {
+    type: 'fts';
+    fields: string;
+    tokenizer: 'ngram';
+    gramSize: number;
+};
 export interface DocumentDataplyInnerMetadata {
     magicString: string;
     version: number;
     createdAt: number;
     updatedAt: number;
     lastId: number;
+    schemeVersion: number;
     indices: {
         [key: string]: [
             number,
-            boolean | {
-                type: 'fts';
-                tokenizer: 'whitespace';
-            } | {
-                type: 'fts';
-                tokenizer: 'ngram';
-                gramSize: number;
-            }
+            IndexMetaConfig
         ];
     };
 }
@@ -42,6 +53,14 @@ export interface DocumentDataplyMetadata {
      * The total number of data rows in the dataply.
      */
     rowCount: number;
+    /**
+     * The list of user-created index names (excludes internal '_id' index).
+     */
+    indices: string[];
+    /**
+     * The current scheme version of the database.
+     */
+    schemeVersion: number;
 }
 export type DataplyDocumentBase = {
     _id: number;
@@ -63,14 +82,6 @@ export type DocumentDataplyQuery<T> = {
 } & {
     [key: string]: any;
 };
-/**
- * Query type restricted to indexed fields only
- */
-export type DocumentDataplyIndexedQuery<T extends DocumentJSON, IC extends IndexConfig<T>> = {
-    [key in keyof IC]: key extends keyof FinalFlatten<DataplyDocument<T>> ? FinalFlatten<DataplyDocument<T>>[key] | DocumentDataplyCondition<FinalFlatten<DataplyDocument<T>>[key]> : never;
-} & DocumentDataplyQuery<{
-    _id: number;
-}>;
 export interface DataplyTreeValue<T> {
     k: number;
     v: T;
@@ -78,7 +89,7 @@ export interface DataplyTreeValue<T> {
 /**
  * Options for querying documents.
  */
-export type DocumentDataplyQueryOptions<T extends DocumentJSON, IC extends IndexConfig<T>> = {
+export type DocumentDataplyQueryOptions = {
     /**
      * The maximum number of documents to return.
      */
@@ -90,7 +101,7 @@ export type DocumentDataplyQueryOptions<T extends DocumentJSON, IC extends Index
     /**
      * The field to order the results by.
      */
-    orderBy?: ExtractIndexKeys<T, IC> | '_id';
+    orderBy?: string;
     /**
      * The order to sort the results by.
      */
@@ -117,12 +128,6 @@ type GetTypeByPath<T, Path extends string> = T extends readonly (infer U)[] ? Pa
 export type FinalFlatten<T> = {
     [P in DeepFlattenKeys<T>]: GetTypeByPath<T, P & string>;
 };
-export type DocumentDataplyIndices<T extends DocumentJSON, IC extends IndexConfig<T>> = {
-    [key in keyof IC & keyof FinalFlatten<T>]: GetTypeByPath<T, key>;
-};
-/**
- * Index configuration type
- */
 export type FTSConfig = {
     type: 'fts';
     tokenizer: 'whitespace';
@@ -131,20 +136,24 @@ export type FTSConfig = {
     tokenizer: 'ngram';
     gramSize: number;
 };
-export type IndexConfig<T> = Partial<{
-    [key in keyof FinalFlatten<T>]: boolean | FTSConfig;
-}>;
 /**
- * Extract index keys from IndexConfig
+ * createIndex option types
  */
-export type ExtractIndexKeys<T extends DocumentJSON, IC extends IndexConfig<T>> = keyof IC & keyof FinalFlatten<DataplyDocument<T>> & string;
-export interface DocumentDataplyOptions<T, IC extends IndexConfig<T> = IndexConfig<T>> extends DataplyOptions {
-    /**
-     * Indices to create when initializing the database.
-     * If not specified, no indices will be created.
-     * If the value of the index is `true`, the index will be created for the already inserted data.
-     * If the value of the index is `false`, the index will not be created for the already inserted data.
-     */
-    indices?: IC;
+export type CreateIndexBTreeOption<T extends DocumentJSON> = {
+    type: 'btree';
+    fields: (DeepFlattenKeys<DataplyDocument<T>> & string)[];
+};
+export type CreateIndexFTSOption<T extends DocumentJSON> = {
+    type: 'fts';
+    fields: DeepFlattenKeys<DataplyDocument<T>> & string;
+    tokenizer: 'whitespace';
+} | {
+    type: 'fts';
+    fields: DeepFlattenKeys<DataplyDocument<T>> & string;
+    tokenizer: 'ngram';
+    ngram: number;
+};
+export type CreateIndexOption<T extends DocumentJSON> = CreateIndexBTreeOption<T> | CreateIndexFTSOption<T>;
+export interface DocumentDataplyOptions extends DataplyOptions {
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "document-dataply",
-  "version": "0.0.8",
+  "version": "0.0.9-alpha.1",
   "description": "Simple and powerful JSON document database supporting complex queries and flexible indexing policies.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",
@@ -42,7 +42,7 @@
     "dataply"
   ],
   "dependencies": {
-    "dataply": "^0.0.23"
+    "dataply": "^0.0.24-alpha.0"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",