@tinacms/graphql 1.0.5 → 1.2.0

package/LICENSE

@@ -1,176 +1,37 @@
-Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
+This license is based on the Fair Source License, version 0.9, with explanatory changes to the Use Limitation.
+
+Copyright ©2023 Forestry.io Holdings Inc. 
+Licensor: Forestry.io Holdings Inc. 
+Software: Tina Data Layer
+Use Limitation: 5 users, 2 roles, and 500 documents per website
+
+License Grant. 
+Licensor hereby grants to each recipient of the Software (“you”) a non-exclusive, non-transferable, royalty-free 
+and fully-paid-up license, under all of the Licensor’s copyright and patent rights, to use, copy, distribute, 
+prepare derivative works of, publicly perform and display the Software, subject to the Use Limitation and the 
+conditions set forth below.
+
+Use Limitation. 
+The license granted above allows use by up to the number of users, roles, and documents, per website  set forth 
+above (the “Use Limitation”). You may only use one copy of the software per website. For determining the number of 
+users, roles, and documents, “you” includes all affiliates, meaning legal entities controlling, controlled by, or 
+under common control with you. If you exceed the Use Limitation, your use is subject to payment of Licensor’s 
+then-current list price for licenses.
+
+Conditions. 
+Redistribution in source code or other forms must include a copy of this license document to be provided in a 
+reasonable manner. Any redistribution of the Software is only allowed subject to this license.
+
+Trademarks. 
+This license does not grant you any right in the trademarks, service marks, brand names or logos of Licensor.
+
+DISCLAIMER. 
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OR CONDITION, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED 
+TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. LICENSORS HEREBY DISCLAIM 
+ALL LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+SOFTWARE.
+
+Termination. 
+If you violate the terms of this license, your rights will terminate automatically and will not be 
+reinstated without the prior written consent of Licensor. Any such termination will not affect the right of others 
+who may have received copies of the Software from you.

package/dist/ast-builder/index.d.ts

@@ -1,14 +1,5 @@
 /**
-Copyright 2021 Forestry.io Holdings, Inc.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
+
 */
 import { FieldDefinitionNode, ScalarTypeDefinitionNode, InputValueDefinitionNode, ObjectTypeDefinitionNode, InterfaceTypeDefinitionNode, NamedTypeNode, UnionTypeDefinitionNode, TypeDefinitionNode, DirectiveNode, EnumTypeDefinitionNode, InputObjectTypeDefinitionNode, DocumentNode, FragmentDefinitionNode, SelectionNode, FieldNode, InlineFragmentNode, OperationDefinitionNode } from 'graphql';
 /**
@@ -147,6 +138,7 @@ export declare const NAMER: {
     dataFilterTypeName: (namespace: string[]) => string;
     dataMutationTypeNameOn: (namespace: string[]) => string;
     dataMutationTypeName: (namespace: string[]) => string;
+    dataMutationUpdateTypeName: (namespace: string[]) => string;
     updateName: (namespace: string[]) => string;
     createName: (namespace: string[]) => string;
     documentQueryName: () => string;

package/dist/build.d.ts

@@ -1,14 +1,5 @@
 /**
-Copyright 2021 Forestry.io Holdings, Inc.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
+
 */
 import { DocumentNode } from 'graphql';
 import { TinaSchema } from '@tinacms/schema-tools';

package/dist/builder/index.d.ts

@@ -1,14 +1,5 @@
 /**
-Copyright 2021 Forestry.io Holdings, Inc.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
+
 */
 import { Database } from '../database';
 import type { ObjectTypeDefinitionNode, InlineFragmentNode, FieldDefinitionNode } from 'graphql';
@@ -251,6 +242,7 @@ export declare class Builder {
     private _buildFieldFilter;
     private _buildFieldMutation;
     private _buildReferenceMutation;
+    private _buildUpdateDocumentMutationParams;
     private _buildObjectOrUnionData;
     private _connectionFilterBuilder;
     private _connectionFieldBuilder;

package/dist/builder/static-definitions.d.ts

@@ -1,13 +1,4 @@
 /**
-Copyright 2021 Forestry.io Holdings, Inc.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
+
 */
 export declare const staticDefinitions: (import("graphql").ScalarTypeDefinitionNode | import("graphql").ObjectTypeDefinitionNode | import("graphql").InterfaceTypeDefinitionNode[])[];

package/dist/database/bridge/filesystem.d.ts

@@ -0,0 +1,24 @@
+import type { Bridge } from './index';
+/**
+ * This is the bridge from whatever datasource we need for I/O.
+ * The basic example here is for the filesystem, one is needed
+ * for Github has well.
+ */
+export declare class FilesystemBridge implements Bridge {
+    rootPath: string;
+    outputPath?: string;
+    constructor(rootPath: string);
+    addOutputPath(outputPath: string): void;
+    glob(pattern: string, extension: string): Promise<string[]>;
+    supportsBuilding(): boolean;
+    delete(filepath: string): Promise<void>;
+    get(filepath: string): Promise<string>;
+    putConfig(filepath: string, data: string): Promise<void>;
+    put(filepath: string, data: string, basePathOverride?: string): Promise<void>;
+}
+/**
+ * Same as the `FileSystemBridge` except it does not save files
+ */
+export declare class AuditFileSystemBridge extends FilesystemBridge {
+    put(filepath: string, data: string): Promise<void>;
+}

package/dist/database/bridge/index.d.ts

@@ -1,24 +1,18 @@
-/**
-Copyright 2021 Forestry.io Holdings, Inc.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
 export interface Bridge {
     rootPath: string;
     glob(pattern: string, extension: string): Promise<string[]>;
+    delete(filepath: string): Promise<void>;
     get(filepath: string): Promise<string>;
     put(filepath: string, data: string): Promise<void>;
-    delete(filepath: string): Promise<void>;
     /**
      * Whether this bridge supports the ability to build the schema.
      */
     supportsBuilding(): boolean;
     putConfig(filepath: string, data: string): Promise<void>;
+    /**
+     * Optionally, the bridge can perform
+     * operations in a separate path.
+     */
+    outputPath?: string;
+    addOutputPath?(outputPath: string): void;
 }

package/dist/database/bridge/isomorphic.d.ts

@@ -0,0 +1,96 @@
+import { CallbackFsClient, PromiseFsClient } from 'isomorphic-git';
+import type { Bridge } from './index';
+export declare type IsomorphicGitBridgeOptions = {
+    gitRoot: string;
+    fsModule?: CallbackFsClient | PromiseFsClient;
+    commitMessage?: string;
+    author: {
+        name: string;
+        email: string;
+    };
+    committer?: {
+        name: string;
+        email: string;
+    };
+    ref?: string;
+    onPut?: (filepath: string, data: string) => Promise<void>;
+    onDelete?: (filepath: string) => Promise<void>;
+};
+/**
+ * Bridge backed by isomorphic-git
+ */
+export declare class IsomorphicBridge implements Bridge {
+    rootPath: string;
+    relativePath: string;
+    gitRoot: string;
+    fsModule: CallbackFsClient | PromiseFsClient;
+    isomorphicConfig: {
+        fs: CallbackFsClient | PromiseFsClient;
+        dir: string;
+    };
+    commitMessage: string;
+    author: {
+        name: string;
+        email: string;
+    };
+    committer: {
+        name: string;
+        email: string;
+    };
+    ref: string | undefined;
+    private readonly onPut;
+    private readonly onDelete;
+    private cache;
+    constructor(rootPath: string, { gitRoot, author, committer, fsModule, commitMessage, ref, onPut, onDelete, }: IsomorphicGitBridgeOptions);
+    private getAuthor;
+    private getCommitter;
+    /**
+     * Recursively populate paths matching `pattern` for the given `entry`
+     *
+     * @param pattern - pattern to filter paths by
+     * @param entry - TreeEntry to start building list from
+     * @param path - base path
+     * @param results
+     * @private
+     */
+    private listEntries;
+    /**
+     * For the specified path, returns an object with an array containing the parts of the path (pathParts)
+     * and an array containing the WalkerEntry objects for the path parts (pathEntries). Any null elements in the
+     * pathEntries are placeholders for non-existent entries.
+     *
+     * @param path - path being resolved
+     * @param ref - ref to resolve path entries for
+     * @private
+     */
+    private resolvePathEntries;
+    /**
+     * Updates tree entry and associated parent tree entries
+     *
+     * @param existingOid - the existing OID
+     * @param updatedOid - the updated OID
+     * @param path - the path of the entry being updated
+     * @param type - the type of the entry being updated (blob or tree)
+     * @param pathEntries - parent path entries
+     * @param pathParts - parent path parts
+     * @private
+     */
+    private updateTreeHierarchy;
+    /**
+     * Creates a commit for the specified tree and updates the specified ref to point to the commit
+     *
+     * @param treeSha - sha of the new tree
+     * @param ref - the ref that should be updated
+     * @private
+     */
+    private commitTree;
+    private getRef;
+    glob(pattern: string, extension: string): Promise<string[]>;
+    supportsBuilding(): boolean;
+    delete(filepath: string): Promise<void>;
+    private qualifyPath;
+    private unqualifyPath;
+    get(filepath: string): Promise<string>;
+    putConfig(filepath: string, data: string): Promise<void>;
+    put(filepath: string, data: string): Promise<void>;
+}

package/dist/database/datalayer.d.ts

@@ -0,0 +1,63 @@
+/**
+
+*/
+import { BatchOp, Level } from './level';
+export declare enum OP {
+    EQ = "eq",
+    GT = "gt",
+    LT = "lt",
+    GTE = "gte",
+    LTE = "lte",
+    STARTS_WITH = "startsWith",
+    IN = "in"
+}
+export declare type BinaryFilter = {
+    pathExpression: string;
+    rightOperand: FilterOperand;
+    operator: OP.EQ | OP.GT | OP.LT | OP.GTE | OP.LTE | OP.STARTS_WITH | OP.IN;
+    type: string;
+    pad?: PadDefinition;
+};
+export declare type TernaryFilter = {
+    pathExpression: string;
+    leftOperand: FilterOperand;
+    rightOperand: FilterOperand;
+    leftOperator: OP.GTE | OP.GT;
+    rightOperator: OP.LT | OP.LTE;
+    type: string;
+    pad?: PadDefinition;
+};
+export declare type IndexDefinition = {
+    fields: {
+        name: string;
+        type?: string;
+        pad?: PadDefinition;
+    }[];
+};
+export declare type PadDefinition = {
+    fillString: string;
+    maxLength: number;
+};
+export declare type FilterOperand = string | number | boolean | string[] | number[];
+export declare type FilterCondition = {
+    filterExpression: Record<string, FilterOperand>;
+    filterPath: string;
+};
+declare type StringEscaper = <T extends string | string[]>(input: T) => T;
+export declare const DEFAULT_COLLECTION_SORT_KEY = "__filepath__";
+export declare const DEFAULT_NUMERIC_LPAD = 4;
+export declare const coerceFilterChainOperands: (filterChain: (BinaryFilter | TernaryFilter)[], escapeString?: StringEscaper) => (BinaryFilter | TernaryFilter)[];
+export declare const makeFilter: ({ filterChain, }: {
+    filterChain?: (BinaryFilter | TernaryFilter)[];
+}) => (values: Record<string, object | FilterOperand>) => boolean;
+export declare const makeFilterChain: ({ conditions, }: {
+    conditions: FilterCondition[];
+}) => (BinaryFilter | TernaryFilter)[];
+export declare const makeFilterSuffixes: (filterChain: (BinaryFilter | TernaryFilter)[], index: IndexDefinition) => {
+    left?: string;
+    right?: string;
+} | undefined;
+export declare const makeIndexOpsForDocument: <T extends object>(filepath: string, collection: string | undefined, indexDefinitions: IndexDefinition[], data: T, opType: 'put' | 'del', level: Level, escapeStr?: StringEscaper) => BatchOp[];
+export declare const makeStringEscaper: (regex: RegExp, replacement: string) => StringEscaper;
+export declare const stringEscaper: StringEscaper;
+export {};

package/dist/database/index.d.ts

@@ -1,31 +1,28 @@
 /**
-Copyright 2021 Forestry.io Holdings, Inc.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
+
 */
-import type { BinaryFilter, IndexDefinition, Store, TernaryFilter } from '@tinacms/datalayer';
 import type { DocumentNode } from 'graphql';
-import type { TinaSchema } from '@tinacms/schema-tools';
-import type { TinaCloudSchemaBase } from '@tinacms/schema-tools';
-import type { Bridge } from './bridge';
+import type { TinaCloudSchemaBase, TinaSchema } from '@tinacms/schema-tools';
+import type { Bridge } from '../database/bridge';
+import { BinaryFilter, IndexDefinition, TernaryFilter } from './datalayer';
+import { Level } from './level';
 declare type IndexStatusEvent = {
     status: 'inprogress' | 'complete' | 'failed';
     error?: Error;
 };
 declare type IndexStatusCallback = (event: IndexStatusEvent) => Promise<void>;
-declare type CreateDatabase = {
-    bridge: Bridge;
-    store: Store;
+export declare type OnPutCallback = (key: string, value: any) => Promise<void>;
+export declare type OnDeleteCallback = (key: string) => Promise<void>;
+export declare type CreateDatabase = {
+    bridge?: Bridge;
+    level: Level;
+    onPut?: (key: string, value: any) => Promise<void>;
+    onDelete?: (key: string) => Promise<void>;
+    tinaDirectory?: string;
     indexStatusCallback?: IndexStatusCallback;
+    version?: boolean;
 };
-export declare const createDatabase: (config: CreateDatabase) => Promise<Database>;
+export declare const createDatabase: (config: CreateDatabase) => Database;
 /** Options for {@link Database.query} **/
 export declare type QueryOptions = {
     fileExtension?: string;
@@ -39,15 +36,23 @@ export declare type QueryOptions = {
 };
 export declare class Database {
     config: CreateDatabase;
-    bridge: Bridge;
-    store: Store;
+    bridge?: Bridge;
+    rootLevel: Level;
+    level: Level | undefined;
+    tinaDirectory: string;
     indexStatusCallback: IndexStatusCallback | undefined;
+    private onPut;
+    private onDelete;
     private tinaSchema;
     private collectionIndexDefinitions;
     private _lookup;
     constructor(config: CreateDatabase);
     private collectionForPath;
+    private getGeneratedFolder;
     private partitionPathsByCollection;
+    private updateDatabaseVersion;
+    private getDatabaseVersion;
+    private initLevel;
     get: <T extends object>(filepath: string) => Promise<T>;
     addPendingDocument: (filepath: string, data: {
         [key: string]: unknown;
@@ -72,9 +77,9 @@ export declare class Database {
     getLookup: (returnType: string) => Promise<LookupMapType>;
     getGraphQLSchema: () => Promise<DocumentNode>;
     getGraphQLSchemaFromBridge: () => Promise<DocumentNode>;
-    getTinaSchema: () => Promise<TinaCloudSchemaBase>;
-    getSchema: () => Promise<TinaSchema>;
-    getIndexDefinitions: () => Promise<Record<string, Record<string, IndexDefinition>>>;
+    getTinaSchema: (level?: Level) => Promise<TinaCloudSchemaBase>;
+    getSchema: (level?: Level) => Promise<TinaSchema>;
+    getIndexDefinitions: (level?: Level) => Promise<Record<string, Record<string, IndexDefinition>>>;
     documentExists: (fullpath: unknown) => Promise<boolean>;
     query: (queryOptions: QueryOptions, hydrator: any) => Promise<{
         edges: {
@@ -93,14 +98,15 @@ export declare class Database {
         tinaSchema: TinaSchema;
     }) => Promise<void>;
     private indexStatusCallbackWrapper;
-    indexContent: ({ graphQLSchema, tinaSchema, }: {
+    indexContent: ({ graphQLSchema, tinaSchema, lookup: lookupFromLockFile, }: {
         graphQLSchema: DocumentNode;
         tinaSchema: TinaSchema;
+        lookup?: object;
     }) => Promise<void>;
     deleteContentByPaths: (documentPaths: string[]) => Promise<void>;
     indexContentByPaths: (documentPaths: string[]) => Promise<void>;
     delete: (filepath: string) => Promise<void>;
-    _indexAllContent: () => Promise<void>;
+    _indexAllContent: (level: Level) => Promise<void>;
     addToLookupMap: (lookup: LookupMapType) => Promise<void>;
 }
 export declare type LookupMapType = GlobalDocumentLookup | CollectionDocumentLookup | MultiCollectionDocumentLookup | MultiCollectionDocumentListLookup | CollectionDocumentListLookup | UnionDataLookup | NodeDocument;

package/dist/database/level.d.ts

@@ -0,0 +1,21 @@
+/**
+
+*/
+/// <reference types="node" />
+import { AbstractLevel, AbstractSublevel, AbstractSublevelOptions } from 'abstract-level';
+export declare type Level = AbstractLevel<Buffer | Uint8Array | string, string, Record<string, any>>;
+export declare type PutOp = {
+    type: 'put';
+    key: string;
+    value: Record<string, any>;
+    sublevel?: AbstractSublevel<Level, Buffer | Uint8Array | string, string, Record<string, any>>;
+};
+export declare type DelOp = {
+    type: 'del';
+    key: string;
+    sublevel?: AbstractSublevel<Level, Buffer | Uint8Array | string, string, Record<string, Record<string, any>>>;
+};
+export declare type BatchOp = PutOp | DelOp;
+export declare const INDEX_KEY_FIELD_SEPARATOR = "\u001D";
+export declare const CONTENT_ROOT_PREFIX = "~";
+export declare const SUBLEVEL_OPTIONS: AbstractSublevelOptions<string, Record<string, any>>;