@sprucelabs/chroma-data-store 0.0.3 → 1.0.0

package/build/esm/ChromaDatabase.js

@@ -0,0 +1,445 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { DataStoresError, generateId, } from '@sprucelabs/data-stores';
+import { assertOptions, flattenValues, expandValues } from '@sprucelabs/schema';
+import { NULL_PLACEHOLDER } from '@sprucelabs/test-utils';
+import { ChromaClient, OllamaEmbeddingFunction, } from 'chromadb';
+import SpruceError from './errors/SpruceError.js';
+export default class ChromaDatabase {
+    constructor(connectionString) {
+        this._isConnected = false;
+        this.collections = {};
+        assertOptions({ connectionString }, ['connectionString']);
+        this.embeddings = new OllamaEmbeddingFunction({
+            model: 'llama3.2',
+            url: 'http://localhost:11434/api/embeddings',
+        });
+        if (!connectionString.startsWith('chroma://')) {
+            throw new DataStoresError({
+                code: 'INVALID_DB_CONNECTION_STRING',
+            });
+        }
+        this.connectionString = connectionString.replace('chroma://', 'http://');
+    }
+    static setEmbeddingsFields(collectionName, fields) {
+        if (!this.embeddingFields) {
+            this.embeddingFields = {};
+        }
+        this.embeddingFields[collectionName] = fields;
+    }
+    static clearEmbeddingsFields() {
+        delete this.embeddingFields;
+    }
+    syncUniqueIndexes(_collectionName, _indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new SpruceError({
+                code: 'FEATURE_NOT_SUPPORTED',
+                operation: 'syncUniqueIndexes',
+            });
+        });
+    }
+    syncIndexes(_collectionName, _indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new SpruceError({
+                code: 'FEATURE_NOT_SUPPORTED',
+                operation: 'syncIndexes',
+            });
+        });
+    }
+    dropIndex(_collectionName, _index) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new SpruceError({
+                code: 'FEATURE_NOT_SUPPORTED',
+                operation: 'dropIndex',
+            });
+        });
+    }
+    getUniqueIndexes(_collectionName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new SpruceError({
+                code: 'FEATURE_NOT_SUPPORTED',
+                operation: 'getUniqueIndexes',
+            });
+        });
+    }
+    getIndexes(_collectionName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new SpruceError({
+                code: 'FEATURE_NOT_SUPPORTED',
+                operation: 'getIndexes',
+            });
+        });
+    }
+    isConnected() {
+        return this._isConnected;
+    }
+    generateId() {
+        return generateId();
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.client = new ChromaClient({ path: this.connectionString });
+            try {
+                yield this.client.heartbeat();
+            }
+            catch (err) {
+                throw new DataStoresError({
+                    code: 'UNABLE_TO_CONNECT_TO_DB',
+                    originalError: err,
+                });
+            }
+            this._isConnected = true;
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._isConnected = false;
+        });
+    }
+    getShouldAutoGenerateId() {
+        return true;
+    }
+    createOne(collection, values, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = yield this.create(collection, [values]);
+            return results[0];
+        });
+    }
+    getCollection(collection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.collections[collection]) {
+                this.collections[collection] =
+                    yield this.client.getOrCreateCollection({
+                        name: collection,
+                        embeddingFunction: this.embeddings,
+                    });
+            }
+            return this.collections[collection];
+        });
+    }
+    buildPrompt(values, collectionName) {
+        var _a;
+        const fields = (_a = ChromaDatabase.embeddingFields) === null || _a === void 0 ? void 0 : _a[collectionName];
+        if ((fields === null || fields === void 0 ? void 0 : fields.length) === 1) {
+            const field = fields[0];
+            return values[field];
+        }
+        let prompt = '';
+        const keys = Object.keys(values);
+        for (const key of keys) {
+            const value = values[key];
+            if (value && typeof value === 'object') {
+                prompt += `${key}:\n\t${this.buildPrompt(value, collectionName)}\n`;
+            }
+            else if (value) {
+                prompt += `${key}: ${value}\n`;
+            }
+        }
+        return prompt.trim();
+    }
+    create(collection, values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const col = yield this.getCollection(collection);
+            const { documents, ids, metadatas } = this.splitValues(values, collection);
+            yield col.add({
+                documents,
+                ids,
+                metadatas,
+            });
+            return this.find(collection, { id: { $in: ids } });
+        });
+    }
+    splitValues(values, collectionName) {
+        const ids = [];
+        const documents = [];
+        const metadatas = [];
+        for (const v of values) {
+            const { id = this.generateId() } = v, values = __rest(v, ["id"]);
+            ids.push(id);
+            documents.push(this.buildPrompt(values, collectionName));
+            const flattened = this.flattenValues(values);
+            metadatas.push(flattened);
+        }
+        return { documents, ids, metadatas };
+    }
+    flattenValues(values) {
+        const flattened = flattenValues(values, [
+            '$or',
+            '*.$gt',
+            '*.$gte',
+            '*.$lt',
+            '*.$lte',
+            '*.$ne',
+        ]);
+        this.dropInNullPlaceholders(flattened);
+        return flattened;
+    }
+    dropInNullPlaceholders(flattened) {
+        for (const key in flattened) {
+            if (flattened[key] === undefined) {
+                flattened[key] = null;
+            }
+            if (flattened[key] === null) {
+                flattened[key] = NULL_PLACEHOLDER;
+            }
+            if (typeof flattened[key] === 'object') {
+                this.dropInNullPlaceholders(flattened[key]);
+            }
+        }
+    }
+    dropCollection(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.client.deleteCollection({ name });
+        });
+    }
+    dropDatabase() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const collections = yield this.client.listCollections();
+            yield Promise.all(collections.map((col) => this.dropCollection(col.name)));
+        });
+    }
+    findOne(collection, query, options, dbOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const matches = yield this.find(collection, query, Object.assign(Object.assign({}, options), { limit: 1 }), dbOptions);
+            return (_a = matches[0]) !== null && _a !== void 0 ? _a : null;
+        });
+    }
+    find(collection, query, options, _dbOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { ids, where, skipIds } = this.buildQuery(query);
+            let matches;
+            const { limit, includeFields } = options !== null && options !== void 0 ? options : {};
+            const col = yield this.getCollection(collection);
+            if (where === null || where === void 0 ? void 0 : where.$prompt) {
+                const { $prompt } = where, rest = __rest(where, ["$prompt"]);
+                const queryResults = yield col.query({
+                    queryTexts: [$prompt],
+                    nResults: 1,
+                    where: Object.keys(rest).length > 0 ? rest : undefined,
+                });
+                matches = {
+                    ids: queryResults.ids[0],
+                    metadatas: queryResults.metadatas[0],
+                };
+            }
+            else {
+                matches = yield col.get({
+                    ids,
+                    include: ['metadatas'],
+                    where,
+                    limit: limit == 0 ? 1 : limit,
+                });
+            }
+            if (!matches || !matches.ids[0]) {
+                return [];
+            }
+            let records = this.mapResultsToRecords(limit, matches, skipIds);
+            if (includeFields) {
+                records = this.filterFieldsByInclude(records, includeFields);
+            }
+            return records;
+        });
+    }
+    mapResultsToRecords(limit, matches, skipIds) {
+        var _a;
+        let records = [];
+        const total = limit !== null && limit !== void 0 ? limit : matches.ids.length;
+        for (let i = 0; i < total; i++) {
+            const values = (_a = matches.metadatas[i]) !== null && _a !== void 0 ? _a : {};
+            const id = matches.ids[i];
+            if (!skipIds.includes(id)) {
+                records.push(Object.assign({ id }, this.expandValues(values)));
+            }
+        }
+        return records;
+    }
+    filterFieldsByInclude(records, includeFields) {
+        const trimmedRecords = [];
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
+        for (let c = 0; c < records.length; c++) {
+            const record = {};
+            for (const key of includeFields) {
+                record[key] = records[c][key];
+            }
+            trimmedRecords.push(record);
+        }
+        return trimmedRecords;
+    }
+    buildQuery(query) {
+        const _a = query !== null && query !== void 0 ? query : {}, { id } = _a, rest = __rest(_a, ["id"]);
+        let ids;
+        let where;
+        if (id === null || id === void 0 ? void 0 : id.$in) {
+            ids = id.$in;
+        }
+        else if (id) {
+            ids = [id];
+        }
+        else if (query) {
+            where = rest;
+        }
+        if ((where === null || where === void 0 ? void 0 : where.$or) && where.$or.length === 1) {
+            //@ts-ignore
+            where = where.$or[0];
+        }
+        if (where) {
+            const { $or, $prompt } = where, rest = __rest(where, ["$or", "$prompt"]);
+            if ($or) {
+                where.$or = $or;
+            }
+            else {
+                where = this.flattenValues(rest);
+                if (Object.keys(where).length > 1) {
+                    const $and = [];
+                    for (const key in where) {
+                        //@ts-ignore
+                        $and.push({ [key]: where[key] });
+                    }
+                    where = {
+                        $and,
+                    };
+                }
+            }
+            if ($prompt) {
+                where.$prompt = $prompt;
+            }
+        }
+        const firstId = ids === null || ids === void 0 ? void 0 : ids[0];
+        const skipIds = [];
+        //@ts-ignore
+        if (firstId === null || firstId === void 0 ? void 0 : firstId['$ne']) {
+            //@ts-ignore
+            skipIds.push(firstId.$ne);
+            ids = undefined;
+        }
+        if (Object.keys(where !== null && where !== void 0 ? where : {}).length === 0) {
+            where = undefined;
+        }
+        return { ids, where, skipIds };
+    }
+    expandValues(values) {
+        const nulledValues = {};
+        for (const key in values) {
+            if (values[key] === NULL_PLACEHOLDER) {
+                nulledValues[key] = null;
+            }
+            else {
+                nulledValues[key] = values[key];
+            }
+        }
+        return expandValues(nulledValues);
+    }
+    updateOne(collection, query, updates, _dbOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const col = yield this.getCollection(collection);
+            const match = yield this.findOne(collection, query);
+            if (!match) {
+                throw new DataStoresError({
+                    code: 'RECORD_NOT_FOUND',
+                    query,
+                    storeName: collection,
+                });
+            }
+            const { documents, metadatas } = this.splitValues([updates], collection);
+            yield col.update({
+                ids: [match.id],
+                documents,
+                metadatas,
+            });
+            const { id } = match, values = __rest(match, ["id"]);
+            return Object.assign(Object.assign({ id }, values), updates);
+        });
+    }
+    update(collection, query, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const matches = yield this.find(collection, query);
+            for (const match of matches) {
+                yield this.updateOne(collection, { id: match.id }, updates);
+            }
+            return matches.length;
+        });
+    }
+    upsertOne(collection, query, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const col = yield this.getCollection(collection);
+            const match = yield this.findOne(collection, query);
+            let { documents, ids, metadatas } = this.splitValues([updates], collection);
+            if (match === null || match === void 0 ? void 0 : match.id) {
+                ids = [match.id];
+            }
+            yield col.upsert({
+                documents,
+                ids,
+                metadatas,
+            });
+            const updated = yield this.findOne(collection, { id: ids[0] });
+            return updated;
+        });
+    }
+    delete(collection, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const matches = yield this.find(collection, query);
+            const col = yield this.getCollection(collection);
+            yield col.delete({
+                ids: matches.map((m) => m.id),
+            });
+            return matches.length;
+        });
+    }
+    deleteOne(collection, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const match = yield this.findOne(collection, query);
+            yield this.delete(collection, { id: match === null || match === void 0 ? void 0 : match.id });
+            return match ? 1 : 0;
+        });
+    }
+    count(collection, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const matches = yield this.find(collection, query);
+            return matches.length;
+        });
+    }
+    createUniqueIndex(_collection, _index) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new SpruceError({
+                code: 'FEATURE_NOT_SUPPORTED',
+                operation: 'createUniqueIndex',
+            });
+        });
+    }
+    createIndex(_collection, _index) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new SpruceError({
+                code: 'FEATURE_NOT_SUPPORTED',
+                operation: 'createIndex',
+            });
+        });
+    }
+    query(_query, _params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new SpruceError({
+                code: 'FEATURE_NOT_SUPPORTED',
+                operation: 'query',
+            });
+        });
+    }
+}

package/build/esm/chroma.types.d.ts

@@ -0,0 +1,177 @@
+import { AddRecordsParams, UpsertRecordsParams, GetResponse, UpdateRecordsParams, QueryRecordsParams, QueryResponse, CollectionMetadata, CollectionParams, PeekParams, DeleteParams, ID, IDs, Where, IncludeEnum, WhereDocument } from 'chromadb';
+export interface Collection {
+    add(params: AddRecordsParams): Promise<void>;
+    /**
+     * Upsert items to the collection
+     * @param {Object} params - The parameters for the query.
+     * @param {ID | IDs} [params.ids] - IDs of the items to add.
+     * @param {Embedding | Embeddings} [params.embeddings] - Optional embeddings of the items to add.
+     * @param {Metadata | Metadatas} [params.metadatas] - Optional metadata of the items to add.
+     * @param {Document | Documents} [params.documents] - Optional documents of the items to add.
+     * @returns {Promise<void>}
+     *
+     * @example
+     * ```typescript
+     * const response = await collection.upsert({
+     *   ids: ["id1", "id2"],
+     *   embeddings: [[1, 2, 3], [4, 5, 6]],
+     *   metadatas: [{ "key": "value" }, { "key": "value" }],
+     *   documents: ["document1", "document2"],
+     * });
+     * ```
+     */
+    upsert(params: UpsertRecordsParams): Promise<void>;
+    /**
+     * Count the number of items in the collection
+     * @returns {Promise<number>} - The number of items in the collection.
+     *
+     * @example
+     * ```typescript
+     * const count = await collection.count();
+     * ```
+     */
+    count(): Promise<number>;
+    /**
+     * Get items from the collection
+     * @param {Object} params - The parameters for the query.
+     * @param {ID | IDs} [params.ids] - Optional IDs of the items to get.
+     * @param {Where} [params.where] - Optional where clause to filter items by.
+     * @param {PositiveInteger} [params.limit] - Optional limit on the number of items to get.
+     * @param {PositiveInteger} [params.offset] - Optional offset on the items to get.
+     * @param {IncludeEnum[]} [params.include] - Optional list of items to include in the response.
+     * @param {WhereDocument} [params.whereDocument] - Optional where clause to filter items by.
+     * @returns {Promise<GetResponse>} - The response from the server.
+     *
+     * @example
+     * ```typescript
+     * const response = await collection.get({
+     *   ids: ["id1", "id2"],
+     *   where: { "key": "value" },
+     *   limit: 10,
+     *   offset: 0,
+     *   include: ["embeddings", "metadatas", "documents"],
+     *   whereDocument: { $contains: "value" },
+     * });
+     * ```
+     */
+    get(options?: BaseGetParams): Promise<GetResponse>;
+    /**
+     * Update items in the collection
+     * @param {Object} params - The parameters for the query.
+     * @param {ID | IDs} [params.ids] - IDs of the items to add.
+     * @param {Embedding | Embeddings} [params.embeddings] - Optional embeddings of the items to add.
+     * @param {Metadata | Metadatas} [params.metadatas] - Optional metadata of the items to add.
+     * @param {Document | Documents} [params.documents] - Optional documents of the items to add.
+     * @returns {Promise<void>}
+     *
+     * @example
+     * ```typescript
+     * const response = await collection.update({
+     *   ids: ["id1", "id2"],
+     *   embeddings: [[1, 2, 3], [4, 5, 6]],
+     *   metadatas: [{ "key": "value" }, { "key": "value" }],
+     *   documents: ["document1", "document2"],
+     * });
+     * ```
+     */
+    update(params: UpdateRecordsParams): Promise<void>;
+    /**
+     * Performs a query on the collection using the specified parameters.
+     *
+     * @param {Object} params - The parameters for the query.
+     * @param {Embedding | Embeddings} [params.queryEmbeddings] - Optional query embeddings to use for the search.
+     * @param {PositiveInteger} [params.nResults] - Optional number of results to return (default is 10).
+     * @param {Where} [params.where] - Optional query condition to filter results based on metadata values.
+     * @param {string | string[]} [params.queryTexts] - Optional query text(s) to search for in the collection.
+     * @param {WhereDocument} [params.whereDocument] - Optional query condition to filter results based on document content.
+     * @param {IncludeEnum[]} [params.include] - Optional array of fields to include in the result, such as "metadata" and "document".
+     *
+     * @returns {Promise<QueryResponse>} A promise that resolves to the query results.
+     * @throws {Error} If there is an issue executing the query.
+     * @example
+     * // Query the collection using embeddings
+     * const results = await collection.query({
+     *   queryEmbeddings: [[0.1, 0.2, ...], ...],
+     *   nResults: 10,
+     *   where: {"name": {"$eq": "John Doe"}},
+     *   include: ["metadata", "document"]
+     * });
+     * @example
+     * ```js
+     * // Query the collection using query text
+     * const results = await collection.query({
+     *   queryTexts: "some text",
+     *   nResults: 10,
+     *   where: {"name": {"$eq": "John Doe"}},
+     *   include: ["metadata", "document"]
+     * });
+     * ```
+     *
+     */
+    query({ nResults, where, whereDocument, include, queryTexts, queryEmbeddings, }: QueryRecordsParams): Promise<QueryResponse>;
+    /**
+     * Modify the collection name or metadata
+     * @param {Object} params - The parameters for the query.
+     * @param {string} [params.name] - Optional new name for the collection.
+     * @param {CollectionMetadata} [params.metadata] - Optional new metadata for the collection.
+     * @returns {Promise<void>} - The response from the API.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.updateCollection({
+     *   name: "new name",
+     *   metadata: { "key": "value" },
+     * });
+     * ```
+     */
+    modify({ name, metadata, }: {
+        name?: string;
+        metadata?: CollectionMetadata;
+    }): Promise<CollectionParams>;
+    /**
+     * Peek inside the collection
+     * @param {Object} params - The parameters for the query.
+     * @param {PositiveInteger} [params.limit] - Optional number of results to return (default is 10).
+     * @returns {Promise<GetResponse>} A promise that resolves to the query results.
+     * @throws {Error} If there is an issue executing the query.
+     *
+     * @example
+     * ```typescript
+     * const results = await collection.peek({
+     *   limit: 10
+     * });
+     * ```
+     */
+    peek(options?: PeekParams): Promise<GetResponse>;
+    /**
+     * Deletes items from the collection.
+     * @param {Object} params - The parameters for deleting items from the collection.
+     * @param {ID | IDs} [params.ids] - Optional ID or array of IDs of items to delete.
+     * @param {Where} [params.where] - Optional query condition to filter items to delete based on metadata values.
+     * @param {WhereDocument} [params.whereDocument] - Optional query condition to filter items to delete based on document content.
+     * @returns {Promise<string[]>} A promise that resolves to the IDs of the deleted items.
+     * @throws {Error} If there is an issue deleting items from the collection.
+     *
+     * @example
+     * ```typescript
+     * const results = await collection.delete({
+     *   ids: "some_id",
+     *   where: {"name": {"$eq": "John Doe"}},
+     *   whereDocument: {"$contains":"search_string"}
+     * });
+     * ```
+     */
+    delete(options?: DeleteParams): Promise<void>;
+}
+interface BaseGetParams {
+    ids?: ID | IDs;
+    where?: Where;
+    limit?: number;
+    offset?: number;
+    include?: IncludeEnum[];
+    whereDocument?: WhereDocument;
+}
+export type WhereWithPrompt = Where & {
+    $prompt?: string;
+};
+export {};

package/build/esm/chroma.types.js

@@ -0,0 +1 @@
+export {};

package/build/esm/errors/SpruceError.d.ts

@@ -0,0 +1,6 @@
+import BaseSpruceError from '@sprucelabs/error';
+import ErrorOptions from './../.spruce/errors/options.types';
+export default class SpruceError extends BaseSpruceError<ErrorOptions> {
+    /** an easy to understand version of the errors */
+    friendlyMessage(): string;
+}

package/build/esm/errors/SpruceError.js

@@ -0,0 +1,19 @@
+import BaseSpruceError from '@sprucelabs/error';
+export default class SpruceError extends BaseSpruceError {
+    /** an easy to understand version of the errors */
+    friendlyMessage() {
+        const { options } = this;
+        let message;
+        switch (options === null || options === void 0 ? void 0 : options.code) {
+            case 'FEATURE_NOT_SUPPORTED':
+                message = `I'm sorry, but you can't run ${options.operation} operation on the Chromadb`;
+                break;
+            default:
+                message = super.friendlyMessage();
+        }
+        const fullMessage = options.friendlyMessage
+            ? options.friendlyMessage
+            : message;
+        return fullMessage;
+    }
+}

package/build/esm/errors/featureNotSupported.builder.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    id: string;
+    name: string;
+    fields: {
+        operation: {
+            type: "text";
+            isRequired: true;
+        };
+    };
+};
+export default _default;

package/build/esm/errors/featureNotSupported.builder.js

@@ -0,0 +1,11 @@
+import { buildErrorSchema } from '@sprucelabs/schema';
+export default buildErrorSchema({
+    id: 'featureNotSupported',
+    name: 'Feature not supported',
+    fields: {
+        operation: {
+            type: 'text',
+            isRequired: true,
+        },
+    },
+});

package/build/esm/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ChromaDatabase } from './ChromaDatabase';
+export * from './ChromaDatabase';

package/build/esm/index.js

@@ -0,0 +1,5 @@
+export { default as ChromaDatabase } from './ChromaDatabase.js';
+import { DatabaseFactory } from '@sprucelabs/data-stores';
+import ChromaDatabase from './ChromaDatabase.js';
+export * from './ChromaDatabase.js';
+DatabaseFactory.addAdapter('chroma://', ChromaDatabase);

package/build/index.js

@@ -24,4 +24,3 @@ const data_stores_1 = require("@sprucelabs/data-stores");
 const ChromaDatabase_2 = __importDefault(require("./ChromaDatabase"));
 __exportStar(require("./ChromaDatabase"), exports);
 data_stores_1.DatabaseFactory.addAdapter('chroma://', ChromaDatabase_2.default);
-//# sourceMappingURL=index.js.map