@tinacms/graphql 0.56.1 → 0.57.0-hotfix

package/dist/{cache/lru.d.ts → mdx/index.d.ts}

@@ -1,26 +1,21 @@
 /**
+
 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 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 { parseMDX } from './parse';
+import { stringifyMDX } from './stringify';
+export { parseMDX };
+export { stringifyMDX };

package/dist/mdx/parse.d.ts

@@ -0,0 +1,229 @@
+/**
+
+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 { Content } from 'mdast';
+import type { RichTypeInner } from '../types';
+export declare const parseMDX: (value: string, field: RichTypeInner) => {
+    type: string;
+    children: any;
+};
+/**
+ * ### Convert the MDXAST into an API-friendly format
+ *
+ * When we parse with Remark + MDX we get an AST which has a ton of JS capabilities, meaning
+ * we could pass this back into a JS runtime and evaluate it. Ex.
+ *
+ * ```mdx
+ * ## Hello world! The time and date is: {(new Date().toLocaleString())}
+ * ```
+ *
+ * However, as an intentional constraint we don't want this information as part of our API, as
+ * we don't intend to support the true JS runtime properties of MDX. Rather, we're using MDX for
+ * it's expressive syntax and it's advanced tooling with how it parses JSX inside Markdown.
+ *
+ * Parsing here does 2 things:
+ *
+ * #### Remove non-literal uses of JSX
+ * Things like <MyComponent myProp={() => alert("HI")} /> are not supported and will be ignored
+ *
+ * #### Convert remark nodes to slate-compatible nodes
+ *
+ * A remark node might look like this:
+ * ```js
+ * {
+ *   type: "heading",
+ *   depth: 1
+ *   children: [{type: 'text', value: 'Hello'}]
+ * }
+ * ```
+ * A slate-compatible node would be:
+ * ```js
+ * {
+ *   type: "heading_one",
+ *   children: [{type: 'text', text: 'Hello'}]
+ * }
+ * ```
+ * It's not a huge difference, but in general slate does better with less layers of indirection.
+ *
+ * While it may be desirable to ultimately serve a remark AST shape as part of the API response,
+ * it's currently much easier to only support the shape that works with Slate. This is ok for now for 2
+ * reasons.
+ *
+ * 1. Us providing the `TinaMarkdown` component on the frontend abstracts away an work the developer
+ * would need to do, so it doesn't really matter what shape the response is as long as the external API
+ * doesn't change
+ *
+ * 2. We don't need to do any client-side parsing. Since TinaMarkdown and the slate editor work with the same
+ * format we can just allow Tina to do it's thing and update the form valuse with no additional work.
+ */
+export declare const parseMDXInner: (tree: any, field: RichTypeInner) => {
+    type: string;
+    children: any;
+};
+export interface NodeTypes {
+    paragraph: string;
+    block_quote: string;
+    code_block: string;
+    link: string;
+    image: string;
+    ul_list: string;
+    ol_list: string;
+    listItem: string;
+    heading: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+    };
+    emphasis_mark: string;
+    strong_mark: string;
+    delete_mark: string;
+    inline_code_mark: string;
+    thematic_break: string;
+}
+export declare type SlateNodeType = {
+    type: 'heading_one';
+    children: SlateNodeType[];
+} | {
+    type: 'heading_two';
+    children: SlateNodeType[];
+} | {
+    type: 'heading_three';
+    children: SlateNodeType[];
+} | {
+    type: 'heading_four';
+    children: SlateNodeType[];
+} | {
+    type: 'heading_five';
+    children: SlateNodeType[];
+} | {
+    type: 'heading_six';
+    children: SlateNodeType[];
+} | {
+    type: 'paragraph';
+    children: SlateNodeType[];
+} | {
+    children: SlateNodeType[];
+    link: string;
+    type: 'link';
+} | {
+    type: 'block_quote';
+    children: SlateNodeType[];
+} | {
+    type: 'text';
+    text: string;
+} | {
+    type: 'mdxJsxTextElement';
+    props: object;
+    children: SlateNodeType[];
+    name: string;
+} | {
+    type: 'mdxJsxFlowElement';
+    props: object;
+    children: SlateNodeType[];
+    name: string;
+} | {
+    type: 'block_quote';
+    children: SlateNodeType[];
+} | {
+    type: 'code_block';
+    language: string;
+    value: string;
+} | {
+    type: 'image';
+    link: string;
+    caption: string;
+} | {
+    type: 'thematic_break';
+};
+declare type RecursivePartial<T> = {
+    [P in keyof T]?: RecursivePartial<T[P]>;
+};
+export interface OptionType {
+    nodeTypes?: RecursivePartial<NodeTypes>;
+    linkDestinationKey?: string;
+    imageSourceKey?: string;
+    imageCaptionKey?: string;
+}
+export interface MdastNode {
+    type?: string;
+    ordered?: boolean;
+    value?: string;
+    text?: string;
+    children?: Array<MdastNode>;
+    depth?: 1 | 2 | 3 | 4 | 5 | 6;
+    url?: string;
+    alt?: string;
+    lang?: string;
+    position?: any;
+    spread?: any;
+    checked?: any;
+    indent?: any;
+}
+declare type MdxJsxFlowElement = {
+    type: 'mdxJsxFlowElement';
+    name: string;
+    attributes: object;
+    children: MdxAstNode[];
+};
+declare type MdxJsxTextElement = {
+    type: 'mdxJsxTextElement';
+    name: string;
+    attributes: object;
+    children: MdxAstNode[];
+};
+declare type MdxAstNode = Content | MdxJsxFlowElement | MdxJsxTextElement;
+export declare const plateElements: {
+    ELEMENT_H1: string;
+    ELEMENT_H2: string;
+    ELEMENT_H3: string;
+    ELEMENT_H4: string;
+    ELEMENT_H5: string;
+    ELEMENT_H6: string;
+    ELEMENT_HR: string;
+    ELEMENT_ALIGN_CENTER: string;
+    ELEMENT_ALIGN_JUSTIFY: string;
+    ELEMENT_ALIGN_LEFT: string;
+    ELEMENT_ALIGN_RIGHT: string;
+    ELEMENT_BLOCKQUOTE: string;
+    ELEMENT_CODE_BLOCK: string;
+    ELEMENT_CODE_LINE: string;
+    ELEMENT_DEFAULT: string;
+    ELEMENT_IMAGE: string;
+    ELEMENT_LI: string;
+    ELEMENT_LIC: string;
+    ELEMENT_LINK: string;
+    ELEMENT_MEDIA_EMBED: string;
+    ELEMENT_MENTION: string;
+    ELEMENT_OL: string;
+    ELEMENT_PARAGRAPH: string;
+    ELEMENT_TABLE: string;
+    ELEMENT_TD: string;
+    ELEMENT_TH: string;
+    ELEMENT_TODO_LI: string;
+    ELEMENT_TR: string;
+    ELEMENT_UL: string;
+    MARK_ITALIC: string;
+    MARK_BOLD: string;
+    MARK_STRIKETHROUGH: string;
+    MARK_UNDERLINE: string;
+};
+export declare const defaultNodeTypes: NodeTypes;
+export default function remarkToSlate(node: MdxAstNode): any;
+export {};

package/dist/mdx/stringify.d.ts

@@ -0,0 +1,24 @@
+/**
+
+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 { RichTypeInner } from '../types';
+import { plateElements } from './parse';
+import type { Content } from 'mdast';
+export declare const stringifyMDX: (value: unknown, field: RichTypeInner) => string;
+export declare const stringify: (node: {
+    type: typeof plateElements;
+}, field: RichTypeInner) => Content;

package/dist/primitives/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/primitives/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,33 @@ 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 | {
+        name: {
+            kind: "Name";
+            value: string;
+        };
+        kind: "Field";
+        selectionSet: {
+            kind: "SelectionSet";
+            selections: import("graphql").SelectionNode[];
+        };
+    }>;
+    private _buildFieldNodeForFragments;
+    buildTemplateFragments(template: Template<true>): Promise<InlineFragmentNode>;
     /**
      * ```graphql
      * # ex.

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

@@ -18,35 +18,14 @@ export declare type GithubManagerInit = {
     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;
     glob(pattern: string): Promise<string[]>;
     get(filepath: string): Promise<string>;
     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/primitives/index.d.ts

@@ -12,7 +12,6 @@ limitations under the License.
 */
 import { indexDB } from './build';
 import { resolve } from './resolve';
-import { simpleCache } from '../cache/lru';
 import { createDatabase } from './database';
 export { createDatabase, resolve, indexDB };
 export type { TinaCloudSchema } from './types';
@@ -25,7 +24,7 @@ export declare const gql: ({ rootPath, query, variables, }: {
 }, {
     [key: string]: any;
 }>>;
-export declare const githubRoute: ({ rootPath, query, variables, cacheType, branch, ...githubArgs }: {
+export declare const githubRoute: ({ rootPath, query, variables, branch, ...githubArgs }: {
     accessToken: string;
     owner: string;
     repo: string;
@@ -33,7 +32,6 @@ export declare const githubRoute: ({ rootPath, query, variables, cacheType, bran
     variables: object;
     rootPath?: string;
     branch: string;
-    cacheType?: typeof simpleCache;
 }) => Promise<import("graphql").ExecutionResult<{
     [key: string]: any;
 }, {

package/dist/primitives/types.d.ts

@@ -215,7 +215,7 @@ export declare type TinaCloudTemplateEnriched = GlobalTemplate<true>;
 /**
  * Templates allow you to define an object as polymorphic
  */
-declare type Template<WithNamespace extends boolean> = WithNamespace extends true ? {
+export declare type Template<WithNamespace extends boolean> = WithNamespace extends true ? {
     label: string;
     name: string;
     fields: TinaFieldInner<WithNamespace>[];

package/dist/resolve.d.ts

@@ -0,0 +1,22 @@
+/**
+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 { Database } from './database';
+export declare const resolve: ({ query, variables, database, }: {
+    query: string;
+    variables: object;
+    database: Database;
+}) => Promise<import("graphql").ExecutionResult<{
+    [key: string]: any;
+}, {
+    [key: string]: any;
+}>>;

package/dist/resolver/error.d.ts

@@ -0,0 +1,25 @@
+/**
+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 { ASTNode, GraphQLError, Source, SourceLocation } from 'graphql';
+export declare class TinaError extends Error implements GraphQLError {
+    extensions: Record<string, any>;
+    readonly name: string;
+    readonly locations: ReadonlyArray<SourceLocation> | undefined;
+    readonly path: ReadonlyArray<string | number> | undefined;
+    readonly source: Source | undefined;
+    readonly positions: ReadonlyArray<number> | undefined;
+    readonly nodes: ReadonlyArray<ASTNode> | undefined;
+    originalError: Error | null | undefined;
+    [key: string]: any;
+    constructor(message: string, extensions?: Record<string, any>);
+}