@tinacms/graphql 0.0.0-202196172233 → 0.0.0-202201022290

package/CHANGELOG.md

@@ -1,6 +1,121 @@
 # tina-graphql
 
-## 0.0.0-202196172233
+## 0.0.0-202201022290
+
+### Patch Changes
+
+- b66aefde1: Fixed issue where one could not add a title and then a bold text
+
+## 0.59.3
+
+### Patch Changes
+
+- 34cd3a44a: Fix issue where frontmatter parser would return a Date object which would be cast to epoch format
+- b006a5ab9: Added delete button to image field
+- a324b9c37: Export utilities for working with the data layer
+- 80732bd97: Create a @tinacms/datalayer package which houses the logic for data management for the GraphQL API. This simplifies the @tinacms/graphql package and allows for a clearer separation.
+- 0bec208e2: validate the schema for `path` and `matches`
+- 5c070a83f: feat: Add UI banner for when in localMode
+
+## 0.59.2
+
+### Patch Changes
+
+- 212685fc3: Allow indexDB to skip building the query and fragment generation files
+
+## 0.59.1
+
+### Patch Changes
+
+- f46c6f987: Fix type definitions for schema metadata so they're optional
+
+## 0.59.0
+
+### Minor Changes
+
+- 62bea7019: #2323: fix saving bold and italic text in rich-text editor
+
+### Patch Changes
+
+- bd4e1f802: Pin version number from @tinacms/graphql during schema compilation. This can be used to ensure the proper version is provided when working with Tina Cloud
+
+## 0.58.2
+
+### Patch Changes
+
+- fffce3af8: Don't cache graphql schema during resolution, this was causing the schema to go stale, while updating the schema.gql, so GraphQL tooling thought the value was updated, but the server was still holding on to the cached version
+
+## 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
+
+- 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
+
+- 4b7795612: Adds support for collection.templates to TinaAdmin
+
+## 0.56.0
+
+### Minor Changes
+
+- b99baebf1: Add rich-text editor based on mdx, bump React dependency requirement to 16.14
+
+### Patch Changes
+
+- 891623c7c: Adds support for List and Update to TinaAdmin
+
+## 0.55.2
+
+### Patch Changes
+
+- 9ecb392ca: Fix bug which would set markdown body to undefined when the payload was emptry"
+
+## 0.55.1
+
+### Patch Changes
+
+- ff4446c8e: Adds `getDocumentFields()` query for use with Tina Admin
+- 667c33e2a: Add support for rich-text field, update build script to work with unified packages, which are ESM-only
+
+## 0.55.0
 
 ### Minor 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;
@@ -85,12 +115,21 @@ export declare const astBuilder: {
         ID: string;
         SystemInfo: string;
         Boolean: string;
+        JSON: string;
         Node: string;
         PageInfo: string;
         Connection: string;
         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;
@@ -110,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,19 @@
+/**
+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, buildSDK, }: {
+    database: Database;
+    config: TinaSchema['config'];
+    buildSDK?: boolean;
+}) => 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;
@@ -88,6 +88,14 @@ export declare class Builder {
      * @param collections
      */
     multiCollectionDocument: (collections: TinaCloudCollectionEnriched[]) => Promise<import("graphql").FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * {
+     *    getDocumentFields()
+     * }
+     * ```
+     */
+    multiCollectionDocumentFields: () => Promise<import("graphql").FieldDefinitionNode>;
     /**
      * ```graphql
      * # ex.
@@ -161,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.
@@ -212,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/index.d.ts}

@@ -10,20 +10,14 @@ 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.
 */
-/**
- * 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;
-    constructor(rootPath: string);
-    glob(pattern: string): Promise<string[]>;
-    get(filepath: string): Promise<string>;
-    put(filepath: string, data: string): Promise<void>;
-}
 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/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/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,25 +10,16 @@ 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 declare const listBranches: ({ auth, owner, repo }: {
-    auth: any;
-    owner: any;
-    repo: any;
-}) => Promise<import("@octokit/types").OctokitResponse<import("@octokit/types").ReposListBranchesResponseData>>;
-export declare const createBranch: ({ auth, owner, repo, name, baseBranch }: {
-    auth: any;
-    owner: any;
-    repo: any;
-    name: any;
-    baseBranch: any;
-}) => Promise<import("@octokit/types").OctokitResponse<import("@octokit/types").GitCreateRefResponseData>>;
+export { indexDB } from './build';
+export { resolve } from './resolve';
+export { createDatabase } from './database';
+import type { Database } from './database';
+export type { Store } from './database/store';
+export type { Bridge } from './database/bridge';
+export { stringifyFile, parseFile } from './database/util';
+export { sequential } from './util';
+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 type TinaCloudSchema = TinaCloudSchemaBase<false>;
 export declare type TinaSchema = TinaCloudSchema;
 export declare type TinaCloudCollection = TinaCloudCollectionBase<false>;