@tinacms/graphql 0.57.0 → 0.58.1

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # tina-graphql
 
+## 0.58.1
+
+### Patch Changes
+
+- 4700d7ae4: Patch fix to ensure builds include latest dependencies
+
+## 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

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

@@ -183,17 +183,7 @@ export declare class Builder {
      * @public
      * @param collection a Tina Cloud collection
      */
-    collectionFragment: (collection: TinaCloudCollectionEnriched) => Promise<import("graphql").FragmentDefinitionNode | {
-        name: {
-            kind: "Name";
-            value: string;
-        };
-        kind: "Field";
-        selectionSet: {
-            kind: "SelectionSet";
-            selections: import("graphql").SelectionNode[];
-        };
-    }>;
+    collectionFragment: (collection: TinaCloudCollectionEnriched) => Promise<import("graphql").FragmentDefinitionNode>;
     private _buildFieldNodeForFragments;
     buildTemplateFragments(template: Template<true>): Promise<InlineFragmentNode>;
     /**
@@ -247,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,7 +11,7 @@ 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;
@@ -25,7 +25,9 @@ export declare class GithubBridge implements Bridge {
     appOctoKit: Octokit;
     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>;
 }

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/database/store/filesystem.d.ts

@@ -0,0 +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 { 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,10 +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 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;