@tinacms/graphql 0.56.1 → 0.58.0

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # tina-graphql
 
+## 0.58.0
+
+### Minor Changes
+
+- fa7a0419f: Adds experimental support for a data layer between file-based content and the GraphQL API. This allows documents to be indexed so the CMS can behave more like a traditional CMS, with the ability enforce foreign reference constraints and filtering/pagination capabilities.
+
+### Patch Changes
+
+- eb5fbfac7: Ensure GraphQL resolve doesn't access "bridge" documents
+- 47d126029: Fix support of objects in a list for MDX templates
+
+## 0.57.2
+
+### Patch Changes
+
+- edb2f4011: Trim path property on collections during compilation
+
+## 0.57.1
+
+### Patch Changes
+
+- 60729f60c: Adds a `reference` field
+
+## 0.57.0
+
+### Minor Changes
+
+- ed277e3bd: Remove aws dependency and cache logic from GithubBridge
+- d1ed404ba: Add support for auto-generated SDK for type-safe data fetching
+
+### Patch Changes
+
+- 138ceb8c4: Clean up dependencies
+- 577d6a5ad: Adds collection arg back for generic queries as optional
+
 ## 0.56.1
 
 ### Patch Changes

package/dist/{primitives/ast-builder → ast-builder}/index.d.ts

@@ -10,7 +10,7 @@ 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 } from 'graphql';
+import { FieldDefinitionNode, ScalarTypeDefinitionNode, InputValueDefinitionNode, ObjectTypeDefinitionNode, InterfaceTypeDefinitionNode, NamedTypeNode, UnionTypeDefinitionNode, TypeDefinitionNode, DirectiveNode, EnumTypeDefinitionNode, InputObjectTypeDefinitionNode, DocumentNode, FragmentDefinitionNode, SelectionNode, FieldNode, InlineFragmentNode, OperationDefinitionNode } from 'graphql';
 /**
  * the `gql` module provides functions and types which can be
  * used to build up the GraphQL AST. The primary reason for us using
@@ -45,6 +45,13 @@ export declare const astBuilder: {
         required?: boolean;
         values: string[];
     }) => EnumTypeDefinitionNode;
+    FieldNodeDefinition: ({ name, type, args, list, required, }: {
+        name: string;
+        type: string | TypeDefinitionNode;
+        required?: boolean;
+        list?: boolean;
+        args?: InputValueDefinitionNode[];
+    }) => FieldNode;
     FieldDefinition: ({ name, type, args, list, required, }: {
         name: string;
         type: string | TypeDefinitionNode;
@@ -75,6 +82,29 @@ export declare const astBuilder: {
         directives?: DirectiveNode[];
         args?: NamedTypeNode[];
     }) => ObjectTypeDefinitionNode;
+    FieldWithSelectionSetDefinition: ({ name, selections, }: {
+        name: string;
+        selections: SelectionNode[];
+    }) => {
+        name: {
+            kind: "Name";
+            value: string;
+        };
+        kind: "Field";
+        selectionSet: {
+            kind: "SelectionSet";
+            selections: SelectionNode[];
+        };
+    };
+    InlineFragmentDefinition: ({ name, selections, }: {
+        name: string;
+        selections: SelectionNode[];
+    }) => InlineFragmentNode;
+    FragmentDefinition: ({ name, fragmentName, selections, }: {
+        name: string;
+        fragmentName: string;
+        selections: SelectionNode[];
+    }) => FragmentDefinitionNode;
     TYPES: {
         Scalar: (type: scalarNames) => string;
         MultiCollectionDocument: string;
@@ -92,6 +122,14 @@ export declare const astBuilder: {
         Number: string;
         Document: string;
     };
+    QueryOperationDefinition: ({ queryName, fragName, }: {
+        queryName: string;
+        fragName: string;
+    }) => OperationDefinitionNode;
+    ListQueryOperationDefinition: ({ queryName, fragName, }: {
+        queryName: string;
+        fragName: string;
+    }) => OperationDefinitionNode;
     toGraphQLAst: (ast: {
         globalTemplates: TypeDefinitionNode[];
         query: TypeDefinitionNode;
@@ -111,6 +149,7 @@ export declare const NAMER: {
     createName: (namespace: string[]) => string;
     queryName: (namespace: string[]) => string;
     generateQueryListName: (namespace: string[]) => string;
+    fragmentName: (namespace: string[]) => string;
     collectionTypeName: (namespace: string[]) => string;
     documentTypeName: (namespace: string[]) => string;
     dataTypeName: (namespace: string[]) => string;

package/dist/build.d.ts

@@ -0,0 +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.
+*/
+import type { TinaSchema } from './schema';
+import { Database } from './database';
+export declare const indexDB: ({ database, config, }: {
+    database: Database;
+    config: TinaSchema['config'];
+}) => Promise<void>;

package/dist/{primitives/builder → builder}/index.d.ts

@@ -11,8 +11,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 import { Database } from '../database';
-import type { ObjectTypeDefinitionNode } from 'graphql';
-import type { TinaCloudCollectionEnriched } from '../types';
+import type { ObjectTypeDefinitionNode, InlineFragmentNode } from 'graphql';
+import type { TinaCloudCollectionEnriched, Template } from '../types';
 import { TinaSchema } from '../schema';
 export declare const createBuilder: ({ database, tinaSchema, }: {
     database: Database;
@@ -169,6 +169,23 @@ export declare class Builder {
      * @param collection
      */
     collectionDocument: (collection: TinaCloudCollectionEnriched) => Promise<import("graphql").FieldDefinitionNode>;
+    /**
+     * Turns a collection into a fragment that gets updated on build. This fragment does not resolve references
+     * ```graphql
+     * # ex.
+     * fragment AuthorsParts on Authors {
+     *   name
+     *   avatar
+     *   ...
+     * }
+     * ```
+     *
+     * @public
+     * @param collection a Tina Cloud collection
+     */
+    collectionFragment: (collection: TinaCloudCollectionEnriched) => Promise<import("graphql").FragmentDefinitionNode>;
+    private _buildFieldNodeForFragments;
+    buildTemplateFragments(template: Template<true>): Promise<InlineFragmentNode>;
     /**
      * ```graphql
      * # ex.
@@ -220,13 +237,17 @@ export declare class Builder {
      */
     buildStaticDefinitions: () => (import("graphql").ScalarTypeDefinitionNode | ObjectTypeDefinitionNode | import("graphql").InterfaceTypeDefinitionNode[])[];
     private _buildCollectionDocumentType;
+    private _filterCollectionDocumentType;
+    private _buildTemplateFilter;
     private _updateCollectionDocumentMutationType;
     private _buildTemplateMutation;
     private _buildMultiCollectionDocumentDefinition;
     private _buildMultiCollectionDocumentListDefinition;
+    private _buildFieldFilter;
     private _buildFieldMutation;
     private _buildReferenceMutation;
     private _buildObjectOrUnionData;
+    private _connectionFilterBuilder;
     private _connectionFieldBuilder;
     private _buildDataField;
     private _buildTemplateData;

package/dist/{primitives/database/bridge.d.ts → database/bridge/filesystem.d.ts}

@@ -10,6 +10,7 @@ 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 { 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
@@ -19,11 +20,8 @@ export declare class FilesystemBridge implements Bridge {
     rootPath: string;
     constructor(rootPath: string);
     glob(pattern: string): Promise<string[]>;
+    supportsBuilding(): boolean;
     get(filepath: string): Promise<string>;
-    put(filepath: string, data: string): Promise<void>;
-}
-export interface Bridge {
-    glob(pattern: string): Promise<string[]>;
-    get(filepath: string): Promise<string>;
+    putConfig(filepath: string, data: string): Promise<void>;
     put(filepath: string, data: string): Promise<void>;
 }

package/dist/{primitives/database → database/bridge}/github.d.ts

@@ -11,42 +11,23 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 import { Octokit } from '@octokit/rest';
-import { Bridge } from './bridge';
+import { Bridge } from '.';
 export declare type GithubManagerInit = {
     rootPath: string;
     accessToken: string;
     owner: string;
     repo: string;
     ref: string;
-    cache?: typeof dummyCache;
-};
-declare const dummyCache: {
-    get: <T extends string | string[]>(key: string, setter: () => Promise<T>) => Promise<T>;
 };
 export declare class GithubBridge implements Bridge {
     rootPath: string;
     repoConfig: Pick<GithubManagerInit, 'owner' | 'ref' | 'repo'>;
     appOctoKit: Octokit;
-    cache: typeof dummyCache;
-    constructor({ rootPath, accessToken, owner, repo, ref, cache, }: GithubManagerInit);
-    private generateKey;
+    constructor({ rootPath, accessToken, owner, repo, ref }: GithubManagerInit);
     private readDir;
+    supportsBuilding(): boolean;
     glob(pattern: string): Promise<string[]>;
     get(filepath: string): Promise<string>;
+    putConfig(filepath: string, data: string): Promise<void>;
     put(filepath: string, data: string): Promise<void>;
 }
-export declare const clearCache: ({ owner, repo, ref, path, }: {
-    owner: string;
-    repo: string;
-    ref: string;
-    path?: string;
-}) => void;
-/**
- * This is just an example of what you can provide for caching
- * it should be replaced with a scalable solution which shares a cache
- * across lambda instances (like redis)
- */
-export declare const simpleCache: {
-    get: (keyName: string, setter: () => Promise<any>) => Promise<any>;
-};
-export {};

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

@@ -0,0 +1,23 @@
+/**
+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): Promise<string[]>;
+    get(filepath: string): Promise<string>;
+    put(filepath: string, data: string): Promise<void>;
+    /**
+     * Whether this bridge supports the ability to build the schema.
+     */
+    supportsBuilding(): boolean;
+    putConfig(filepath: string, data: string): Promise<void>;
+}

package/dist/{primitives/database → database}/index.d.ts

@@ -10,43 +10,53 @@ 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 { Bridge } from './bridge';
+import type { DocumentNode } from 'graphql';
+import type { TinaSchema } from '../schema';
 import type { TinaCloudSchemaBase } from '../types';
-import { DocumentNode } from 'graphql';
+import type { Store } from './store';
+import type { Bridge } from './bridge';
 declare type CreateDatabase = {
-    rootPath?: string;
-    bridge?: Bridge;
+    bridge: Bridge;
+    store: Store;
 };
 export declare const createDatabase: (config: CreateDatabase) => Promise<Database>;
 export declare class Database {
     config: CreateDatabase;
     bridge: Bridge;
+    store: Store;
     private tinaSchema;
     private _lookup;
     private _graphql;
     private _tinaSchema;
     constructor(config: CreateDatabase);
     get: <T extends object>(filepath: string) => Promise<T>;
+    addPendingDocument: (filepath: string, data: {
+        [key: string]: unknown;
+    }) => Promise<void>;
     put: (filepath: string, data: {
         [key: string]: unknown;
     }) => Promise<boolean>;
+    stringifyFile: (filepath: string, data: {
+        [key: string]: unknown;
+    }) => Promise<{
+        stringifiedFile: string;
+        payload: {
+            [key: string]: unknown;
+        };
+    }>;
+    flush: (filepath: string) => Promise<string>;
     getLookup: (returnType: string) => Promise<LookupMapType>;
     getGraphQLSchema: () => Promise<DocumentNode>;
+    getGraphQLSchemaFromBridge: () => Promise<DocumentNode>;
     getTinaSchema: () => Promise<TinaCloudSchemaBase>;
-    private getSchema;
-    getDocument: (fullPath: unknown) => Promise<{
-        __typename: string;
-        id: string;
-        data: {
-            _collection: string;
-            _template: string;
-        };
-    }>;
+    getSchema: () => Promise<TinaSchema>;
     documentExists: (fullpath: unknown) => Promise<boolean>;
-    getDocumentsForCollection: (collectionName: string) => Promise<string[]>;
+    query: (queryStrings: string[], hydrator: any) => Promise<object[]>;
+    indexData: ({ graphQLSchema, tinaSchema, }: {
+        graphQLSchema: DocumentNode;
+        tinaSchema: TinaSchema;
+    }) => Promise<void>;
     addToLookupMap: (lookup: LookupMapType) => Promise<void>;
-    private stringifyFile;
-    private parseFile;
 }
 export declare type LookupMapType = GlobalDocumentLookup | CollectionDocumentLookup | MultiCollectionDocumentLookup | MultiCollectionDocumentListLookup | CollectionDocumentListLookup | UnionDataLookup | NodeDocument;
 declare type NodeDocument = {

package/dist/{cache/lru.d.ts → database/store/filesystem.d.ts}

@@ -10,17 +10,19 @@ 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 clearCache: ({ owner, repo, ref, path, }: {
-    owner: string;
-    repo: string;
-    ref: string;
-    path?: string;
-}) => void;
-/**
- * This is just an example of what you can provide for caching
- * it should be replaced with a scalable solution which shares a cache
- * across lambda instances (like redis)
- */
-export declare const simpleCache: {
-    get: (keyName: string, setter: () => Promise<any>) => Promise<any>;
-};
+import { Store } from '.';
+export declare class FilesystemStore implements Store {
+    rootPath: string;
+    clear(): Promise<void>;
+    print(): Promise<void>;
+    constructor({ rootPath }: {
+        rootPath?: string;
+    });
+    query(queryStrings: string[]): Promise<object[]>;
+    seed(): Promise<void>;
+    get<T extends object>(filepath: string): Promise<T>;
+    supportsSeeding(): boolean;
+    supportsIndexing(): boolean;
+    glob(pattern: string, callback: any): Promise<any[]>;
+    put(filepath: string, data: object): Promise<void>;
+}

package/dist/database/store/github.d.ts

@@ -0,0 +1,37 @@
+/**
+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 { Octokit } from '@octokit/rest';
+import { Store } from '.';
+export declare type GithubManagerInit = {
+    rootPath: string;
+    accessToken: string;
+    owner: string;
+    repo: string;
+    ref: string;
+};
+export declare class GithubStore implements Store {
+    rootPath: string;
+    repoConfig: Pick<GithubManagerInit, 'owner' | 'ref' | 'repo'>;
+    appOctoKit: Octokit;
+    clear(): Promise<void>;
+    print(): Promise<void>;
+    constructor({ rootPath, accessToken, owner, repo, ref }: GithubManagerInit);
+    query(queryStrings: string[]): Promise<object[]>;
+    supportsSeeding(): boolean;
+    seed(): Promise<void>;
+    private readDir;
+    glob(pattern: string, callback: any): Promise<any[]>;
+    get(filepath: string): Promise<never>;
+    supportsIndexing(): boolean;
+    put(filepath: string, data: object): Promise<void>;
+}

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

@@ -0,0 +1,74 @@
+/**
+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 Store {
+    glob(pattern: string, hydrator?: (fullPath: string) => Promise<object>): Promise<string[]>;
+    get<T extends object>(filepath: string): Promise<T>;
+    clear(): void;
+    /**
+     *
+     * @param queryStrings
+     * Queries are currently structured as prefixed keys where that last portion
+     * of the key is the value provided by the query
+     * ```graphql
+     * {
+     *   getPostsList(filter: {
+     *     title: {
+     *       eq: "Hello, World"
+     *     }
+     *   }) {
+     *      ...
+     *   }
+     * }
+     * ```
+     * Would equate to a query string of:
+     * ```
+     * __attribute__#posts#posts#title#Hello, World
+     * ```
+     * This can be used by a data store as a secondary index of sorts
+     *
+     * It's important to note that for now each query string acts as an "AND" clause,
+     * meaning the resulting records need to be present in _each_ query string.
+     *
+     * @param hydrator
+     * hydrator is an optional callback, which may be useful depending on the storage mechanism.
+     * For example, the in-memory storage only stores the path to its records as its value,
+     * but in something like DynamoDB the query strings may be used to look up the full record,
+     * meaning there's no need to "hydrate" the return value
+     */
+    query(queryStrings: string[], hydrator?: (fullPath: string) => Promise<object>): Promise<object[]>;
+    /**
+     * In this context, seeding is the act of putting records and indexing data into an ephemeral
+     * storage layer for use during the GraphQL runtime. What might seem suprising is that some stores
+     * don't support seeding, this is because they're behaving more like a "bridge" (GithubStore and FilesystemStore).
+     * Currently they're acting as a way to swap out true data-layer behavior with a backwards-compatible
+     * "store". In the future, all stores should be able to query and seed data.
+     *
+     * At this time it seems that it would never make sense to be able to "query" without "seed"-ing, and
+     * there'd be no value in "seeding" without "query"-ing.
+     */
+    seed(filepath: string, data: object, options?: {
+        includeTemplate?: boolean;
+    }): Promise<void>;
+    supportsSeeding(): boolean;
+    /**
+     * Whether this store supports the ability to index data.
+     * Indexing data requires writing arbitrary keys/values to
+     * the external service, so is not advisable to use for
+     * something like Github, which would write commits to the
+     * user's repo.
+     */
+    supportsIndexing(): boolean;
+    put(filepath: string, data: object, options?: {
+        includeTemplate?: boolean;
+    }): Promise<void>;
+}

package/dist/database/store/level.d.ts

@@ -0,0 +1,29 @@
+/**
+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 { Store } from './index';
+import { LevelDB } from 'level';
+export declare class LevelStore implements Store {
+    rootPath: any;
+    db: LevelDB;
+    constructor(rootPath: string, useMemory?: boolean);
+    query(queryStrings: string[], hydrator: any): Promise<any[]>;
+    seed(filepath: string, data: object): Promise<void>;
+    supportsSeeding(): boolean;
+    supportsIndexing(): boolean;
+    print(): Promise<void>;
+    open(): Promise<void>;
+    clear(): Promise<void>;
+    glob(pattern: string, callback: any): Promise<any[]>;
+    get(filepath: string): Promise<any>;
+    put(filepath: string, data: object): Promise<void>;
+}

package/dist/database/store/memory.d.ts

@@ -0,0 +1,33 @@
+/**
+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 { Store } 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 MemoryStore implements Store {
+    rootPath: any;
+    db: any;
+    private map;
+    constructor(rootPath: string, object?: object);
+    query(queryStrings: string[], hydrator: any): Promise<any[]>;
+    seed(filepath: string, data: object): Promise<void>;
+    supportsSeeding(): boolean;
+    supportsIndexing(): boolean;
+    print(): Promise<void>;
+    clear(): Promise<void>;
+    glob(pattern: string, callback: any): Promise<any[]>;
+    get(filepath: string): Promise<any>;
+    put(filepath: string, data: object): Promise<void>;
+}

package/dist/database/util.d.ts

@@ -0,0 +1,16 @@
+/**
+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 * as yup from 'yup';
+export declare const stringifyFile: (content: object, format: FormatType | string, keepTemplateKey: boolean) => string;
+export declare const parseFile: <T extends object>(content: string, format: FormatType | string, yupSchema: (args: typeof yup) => yup.ObjectSchema<any>) => T;
+export declare type FormatType = 'json' | 'md' | 'mdx' | 'markdown';

package/dist/index.d.ts

@@ -10,13 +10,19 @@ 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 { GithubBridge } from './primitives/database/github';
-export type { GithubManagerInit } from './primitives/database/github';
-export { gql, resolve, buildSchema, indexDB, createDatabase, githubRoute, } from './primitives';
-import { clearCache as s3ClearCache, s3Cache } from './cache/s3';
-import { clearCache as lruClearCache, simpleCache } from './cache/lru';
-export { lruClearCache, lruClearCache as clearCache, s3ClearCache, s3Cache, simpleCache, };
-import type { TinaCloudSchema as TinaCloudSchemaBase, TinaCloudCollection as TinaCloudCollectionBase, TinaCloudTemplateBase as TinaTemplate, TinaFieldBase } from './primitives/types';
+export { indexDB } from './build';
+export { resolve } from './resolve';
+export { createDatabase } from './database';
+export { GithubBridge } from './database/bridge/github';
+export { GithubStore } from './database/store/github';
+export { FilesystemBridge } from './database/bridge/filesystem';
+export { FilesystemStore } from './database/store/filesystem';
+export { MemoryStore } from './database/store/memory';
+export { LevelStore } from './database/store/level';
+export type { GithubManagerInit } from './database/bridge/github';
+import type { Database } from './database';
+export declare const buildSchema: (rootPath: string, database: Database) => Promise<import("graphql").GraphQLSchema>;
+import type { TinaCloudSchema as TinaCloudSchemaBase, TinaCloudCollection as TinaCloudCollectionBase, TinaCloudTemplateBase as TinaTemplate, TinaFieldBase } from './types';
 export declare const listBranches: ({ auth, owner, repo }: {
     auth: any;
     owner: any;