@tinacms/graphql 0.0.0-0a77b75-20241004023651

package/dist/level/tinaLevel.d.ts

@@ -0,0 +1,7 @@
+import { ManyLevelGuest } from 'many-level';
+export declare class TinaLevelClient extends ManyLevelGuest<string, Record<string, any>> {
+    private port;
+    private _connected;
+    constructor(port?: number);
+    openConnection(): void;
+}

package/dist/mdx/index.d.ts

@@ -0,0 +1,8 @@
+/**
+
+
+
+*/
+import { parseMDX, stringifyMDX } from '@tinacms/mdx';
+export { parseMDX };
+export { stringifyMDX };

package/dist/resolve.d.ts

@@ -0,0 +1,21 @@
+/**
+
+*/
+import type { GraphQLConfig } from './types';
+import type { Database } from './database';
+export declare const resolve: ({ config, query, variables, database, silenceErrors, verbose, isAudit, ctxUser, }: {
+    config?: GraphQLConfig;
+    query: string;
+    variables: object;
+    database: Database;
+    silenceErrors?: boolean;
+    verbose?: boolean;
+    isAudit?: boolean;
+    ctxUser?: {
+        sub: string;
+    };
+}) => Promise<import("graphql").ExecutionResult<{
+    [key: string]: any;
+}, {
+    [key: string]: any;
+}>>;

package/dist/resolver/error.d.ts

@@ -0,0 +1,46 @@
+/**
+
+*/
+import { ASTNode, GraphQLError, Source, SourceLocation } from 'graphql';
+export declare class TinaGraphQLError 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>);
+}
+export type TypeFetchErrorArgs = {
+    stack?: string;
+    file?: string;
+    includeAuditMessage?: boolean;
+    originalError: Error;
+    collection?: string;
+};
+export declare class TinaFetchError extends Error {
+    stack?: string;
+    collection?: string;
+    file?: string;
+    originalError: Error;
+    constructor(message: string, args: TypeFetchErrorArgs);
+}
+export declare class TinaQueryError extends TinaFetchError {
+    stack?: string;
+    collection?: string;
+    file?: string;
+    originalError: Error;
+    constructor(args: TypeFetchErrorArgs);
+}
+export declare class TinaParseDocumentError extends TinaFetchError {
+    stack?: string;
+    collection?: string;
+    file?: string;
+    originalError: Error;
+    constructor(args: TypeFetchErrorArgs);
+    toString(): string;
+}
+export declare const handleFetchErrorError: (e: unknown, verbose: any) => never;

package/dist/resolver/filter-utils.d.ts

@@ -0,0 +1,13 @@
+/**
+
+*/
+import type { ReferenceType, TinaField } from '@tinacms/schema-tools';
+import { FilterCondition } from '../database/datalayer';
+export type ReferenceResolver = (filter: Record<string, object>, fieldDefinition: ReferenceType) => Promise<{
+    edges: {
+        node: any;
+    }[];
+    values: any[];
+}>;
+export declare const resolveReferences: (filter: any, fields: TinaField[], resolver: ReferenceResolver) => Promise<void>;
+export declare const collectConditionsForField: (fieldName: string, field: TinaField, filterNode: Record<string, object>, pathExpression: string, collectCondition: (condition: FilterCondition) => void) => void;

package/dist/resolver/index.d.ts

@@ -0,0 +1,352 @@
+/**
+
+*/
+import { Database } from '../database';
+import type { Collectable, Collection, TinaField, Template, TinaSchema } from '@tinacms/schema-tools';
+import type { GraphQLConfig } from '../types';
+interface ResolverConfig {
+    config?: GraphQLConfig;
+    database: Database;
+    tinaSchema: TinaSchema;
+    isAudit: boolean;
+}
+export declare const createResolver: (args: ResolverConfig) => Resolver;
+export declare const transformDocumentIntoPayload: (fullPath: string, rawData: {
+    _collection: any;
+    _template: any;
+}, tinaSchema: TinaSchema, config?: GraphQLConfig, isAudit?: boolean) => Promise<{
+    _sys: {
+        title: any;
+        basename: string;
+        filename: string;
+        extension: string;
+        path: string;
+        relativePath: string;
+        breadcrumbs: string[];
+        collection: Collection<true>;
+        template: string | number;
+    };
+    _values: {
+        _collection: any;
+        _template: any;
+    };
+    _rawData: {
+        _collection: any;
+        _template: any;
+    };
+    _collection: any;
+    _template: any;
+    __typename: string;
+    id: string;
+}>;
+/**
+ * The resolver provides functions for all possible types of lookup
+ * values and retrieves them from the database
+ */
+export declare class Resolver {
+    init: ResolverConfig;
+    config: GraphQLConfig;
+    database: Database;
+    tinaSchema: TinaSchema;
+    isAudit: boolean;
+    constructor(init: ResolverConfig);
+    resolveCollection: (args: any, collectionName: string, hasDocuments?: boolean) => Promise<{
+        fields: TinaField<true>[];
+        templates?: undefined;
+        label?: string;
+        name: string;
+        path: string;
+        indexes?: {
+            name: string;
+            fields: {
+                name: string;
+            }[];
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx" | "yaml" | "yml" | "toml";
+        ui?: import("@tinacms/schema-tools").UICollection;
+        defaultItem?: import("@tinacms/schema-tools").DefaultItem<Record<string, any>>;
+        frontmatterFormat?: "yaml" | "toml" | "json";
+        frontmatterDelimiters?: [string, string] | string;
+        match?: {
+            include?: string;
+            exclude?: string;
+        };
+        isDetached?: boolean;
+        isAuthCollection?: boolean;
+        namespace: string[];
+        documents: {
+            collection: Collection<true>;
+            hasDocuments: boolean;
+        };
+    } | {
+        templates: Template<true>[];
+        fields?: undefined;
+        label?: string;
+        name: string;
+        path: string;
+        indexes?: {
+            name: string;
+            fields: {
+                name: string;
+            }[];
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx" | "yaml" | "yml" | "toml";
+        ui?: import("@tinacms/schema-tools").UICollection;
+        defaultItem?: import("@tinacms/schema-tools").DefaultItem<Record<string, any>>;
+        frontmatterFormat?: "yaml" | "toml" | "json";
+        frontmatterDelimiters?: [string, string] | string;
+        match?: {
+            include?: string;
+            exclude?: string;
+        };
+        isDetached?: boolean;
+        isAuthCollection?: boolean;
+        namespace: string[];
+        documents: {
+            collection: Collection<true>;
+            hasDocuments: boolean;
+        };
+    }>;
+    getRaw: (fullPath: unknown) => Promise<{
+        _collection: string;
+        _template: string;
+    }>;
+    getDocumentOrDirectory: (fullPath: unknown) => Promise<{
+        _sys: {
+            title: any;
+            basename: string;
+            filename: string;
+            extension: string;
+            path: string;
+            relativePath: string;
+            breadcrumbs: string[];
+            collection: Collection<true>;
+            template: string | number;
+        };
+        _values: {
+            _collection: any;
+            _template: any;
+        };
+        _rawData: {
+            _collection: any;
+            _template: any;
+        };
+        _collection: any;
+        _template: any;
+        __typename: string;
+        id: string;
+    } | {
+        __typename: string;
+        name: any;
+        path: any;
+    }>;
+    getDocument: (fullPath: unknown) => Promise<{
+        _sys: {
+            title: any;
+            basename: string;
+            filename: string;
+            extension: string;
+            path: string;
+            relativePath: string;
+            breadcrumbs: string[];
+            collection: Collection<true>;
+            template: string | number;
+        };
+        _values: {
+            _collection: any;
+            _template: any;
+        };
+        _rawData: {
+            _collection: any;
+            _template: any;
+        };
+        _collection: any;
+        _template: any;
+        __typename: string;
+        id: string;
+    }>;
+    deleteDocument: (fullPath: unknown) => Promise<void>;
+    buildObjectMutations: (fieldValue: any, field: Collectable, existingData?: Record<string, any> | Record<string, any>[]) => Promise<{
+        [key: string]: unknown;
+    } | {
+        [key: string]: unknown;
+    }[] | {
+        _template: string;
+    }[]>;
+    createResolveDocument: ({ collection, realPath, args, isAddPendingDocument, }: {
+        collection: Collection<true>;
+        realPath: string;
+        args: unknown;
+        isAddPendingDocument: boolean;
+    }) => Promise<{
+        _sys: {
+            title: any;
+            basename: string;
+            filename: string;
+            extension: string;
+            path: string;
+            relativePath: string;
+            breadcrumbs: string[];
+            collection: Collection<true>;
+            template: string | number;
+        };
+        _values: {
+            _collection: any;
+            _template: any;
+        };
+        _rawData: {
+            _collection: any;
+            _template: any;
+        };
+        _collection: any;
+        _template: any;
+        __typename: string;
+        id: string;
+    }>;
+    updateResolveDocument: ({ collection, realPath, args, isAddPendingDocument, isCollectionSpecific, }: {
+        collection: Collection<true>;
+        realPath: string;
+        args: unknown;
+        isAddPendingDocument: boolean;
+        isCollectionSpecific: boolean;
+    }) => Promise<{
+        _sys: {
+            title: any;
+            basename: string;
+            filename: string;
+            extension: string;
+            path: string;
+            relativePath: string;
+            breadcrumbs: string[];
+            collection: Collection<true>;
+            template: string | number;
+        };
+        _values: {
+            _collection: any;
+            _template: any;
+        };
+        _rawData: {
+            _collection: any;
+            _template: any;
+        };
+        _collection: any;
+        _template: any;
+        __typename: string;
+        id: string;
+    }>;
+    /**
+     * Returns top-level fields which are not defined in the collection, so their
+     * values are not eliminated from Tina when new values are saved
+     */
+    resolveLegacyValues: (oldDoc: any, collection: Collection<true>) => {};
+    resolveDocument: ({ args, collection: collectionName, isMutation, isCreation, isDeletion, isFolderCreation, isAddPendingDocument, isCollectionSpecific, isUpdateName, }: {
+        args: unknown;
+        collection?: string;
+        isMutation: boolean;
+        isCreation?: boolean;
+        isDeletion?: boolean;
+        isFolderCreation?: boolean;
+        isAddPendingDocument?: boolean;
+        isCollectionSpecific?: boolean;
+        isUpdateName?: boolean;
+    }) => Promise<{
+        _sys: {
+            title: any;
+            basename: string;
+            filename: string;
+            extension: string;
+            path: string;
+            relativePath: string;
+            breadcrumbs: string[];
+            collection: Collection<true>;
+            template: string | number;
+        };
+        _values: {
+            _collection: any;
+            _template: any;
+        };
+        _rawData: {
+            _collection: any;
+            _template: any;
+        };
+        _collection: any;
+        _template: any;
+        __typename: string;
+        id: string;
+    }>;
+    resolveCollectionConnections: ({ ids }: {
+        ids: string[];
+    }) => Promise<{
+        totalCount: number;
+        edges: {
+            node: {
+                _sys: {
+                    title: any;
+                    basename: string;
+                    filename: string;
+                    extension: string;
+                    path: string;
+                    relativePath: string;
+                    breadcrumbs: string[];
+                    collection: Collection<true>;
+                    template: string | number;
+                };
+                _values: {
+                    _collection: any;
+                    _template: any;
+                };
+                _rawData: {
+                    _collection: any;
+                    _template: any;
+                };
+                _collection: any;
+                _template: any;
+                __typename: string;
+                id: string;
+            };
+        }[];
+    }>;
+    private referenceResolver;
+    private resolveFilterConditions;
+    resolveCollectionConnection: ({ args, collection, hydrator, }: {
+        args: Record<string, Record<string, object> | string | number>;
+        collection: Collection<true>;
+        hydrator?: (string: any) => any;
+    }) => Promise<{
+        totalCount: number;
+        edges: {
+            node: any;
+            cursor: string;
+        }[];
+        pageInfo: {
+            hasPreviousPage: boolean;
+            hasNextPage: boolean;
+            startCursor: string;
+            endCursor: string;
+        };
+    }>;
+    private buildFieldMutations;
+    /**
+     * A mutation looks nearly identical between updateDocument:
+     * ```graphql
+     * updateDocument(collection: $collection,relativePath: $path, params: {
+     *   post: {
+     *     title: "Hello, World"
+     *   }
+     * })`
+     * ```
+     * and `updatePostDocument`:
+     * ```graphql
+     * updatePostDocument(relativePath: $path, params: {
+     *   title: "Hello, World"
+     * })
+     * ```
+     * The problem here is that we don't know whether the payload came from `updateDocument`
+     * or `updatePostDocument` (we could, but for now it's easier not to pipe those details through),
+     * But we do know that when given a `args.collection` value, we can assume that
+     * this was a `updateDocument` request, and thus - should grab the data
+     * from the corresponding field name in the key
+     */
+    private buildParams;
+}
+export {};

package/dist/resolver/media-utils.d.ts

@@ -0,0 +1,21 @@
+/**
+
+*/
+import type { GraphQLConfig } from '../types';
+import type { Schema } from '@tinacms/schema-tools';
+/**
+ * Strips away the Tina Cloud Asset URL from an `image` value
+ *
+ * @param {string | string[]} value
+ * @param {GraphQLConfig} config
+ * @returns {string}
+ */
+export declare const resolveMediaCloudToRelative: (value: string | string[], config: GraphQLConfig, schema: Schema<true>) => string | string[];
+/**
+ * Adds Tina Cloud Asset URL to an `image` value
+ *
+ * @param {string | string[]} value
+ * @param {GraphQLConfig} config
+ * @returns {string}
+ */
+export declare const resolveMediaRelativeToCloud: (value: string | string[], config: GraphQLConfig, schema: Schema<true>) => string | string[];

package/dist/schema/createSchema.d.ts

@@ -0,0 +1,8 @@
+/**
+
+*/
+import { TinaSchema, Schema } from '@tinacms/schema-tools';
+export declare const createSchema: ({ schema, flags, }: {
+    schema: Schema;
+    flags?: string[];
+}) => Promise<TinaSchema>;

package/dist/schema/validate.d.ts

@@ -0,0 +1,11 @@
+/**
+
+*/
+import { type Schema, type Collection } from '@tinacms/schema-tools';
+export declare const validateSchema: (schema: Schema) => Promise<{
+    collections: Collection<true>[];
+    config: import("@tinacms/schema-tools").Config<undefined, undefined, undefined, undefined, undefined>;
+} | {
+    collections: Collection<true>[];
+    config?: undefined;
+}>;

package/dist/sdkBuilder/index.d.ts

@@ -0,0 +1,5 @@
+/**
+
+*/
+import type { TinaSchema } from '@tinacms/schema-tools';
+export declare const buildSKD: (tinaSchema: TinaSchema) => string;

package/dist/spec/setup.d.ts

@@ -0,0 +1,32 @@
+/**
+
+*/
+import type { Schema } from '@tinacms/schema-tools';
+import { Database } from '../database';
+import { Level } from '../database/level';
+export declare const setup: (rootPath: string, schema: Schema, level: Level) => Promise<{
+    database: Database;
+}>;
+export declare const print: (fixture: Fixture) => string;
+export type Fixture = {
+    description?: string;
+    name: string;
+    assert: 'output';
+    message?: string;
+    expectError?: boolean;
+} | {
+    description?: string;
+    name: string;
+    assert: 'file';
+    filename: string;
+    message?: string;
+    expectError?: boolean;
+};
+export declare const setupFixture: (rootPath: string, schema: Schema, level: Level, fixture: Fixture, suffix?: string, queryName?: string, folder?: string) => Promise<{
+    responses: string[];
+    expectedResponsePaths: string[];
+}>;
+export declare const setupFixture2: (rootPath: string, schema: Schema, level: Level, fixture: Fixture, suffix?: string, queryName?: string, folder?: string) => Promise<{
+    responses: string[];
+    expectedResponsePaths: string[];
+}>;

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+/**
+
+*/
+export type GraphQLConfig = {
+    useRelativeMedia: true;
+} | {
+    useRelativeMedia: false;
+    clientId: string;
+    assetsHost: string;
+};

package/dist/util.d.ts

@@ -0,0 +1,21 @@
+/**
+
+*/
+import * as yup from 'yup';
+/**
+ * Iterate through an array of promises sequentially, ensuring the order
+ * is preserved.
+ *
+ * ```js
+ * await sequential(templates, async (template) => {
+ *   await doSomething(template)
+ * })
+ * ```
+ */
+export declare const sequential: <A, B>(items: A[] | undefined, callback: (args: A, idx: number) => Promise<B>) => Promise<B[]>;
+export declare function assertShape<T>(value: unknown, yupSchema: (args: typeof yup) => yup.AnySchema, errorMessage?: string): asserts value is T;
+export declare const atob: (b64Encoded: string) => string;
+export declare const btoa: (string: string) => string;
+export declare const lastItem: (arr: (number | string)[]) => string | number;
+export declare const get: (obj: any, path: any, defaultValue?: any) => any;
+export declare const flattenDeep: (arr: any) => any;

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@tinacms/graphql",
+  "version": "0.0.0-0a77b75-20241004023651",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "package.json",
+    "dist"
+  ],
+  "exports": {
+    "import": "./dist/index.mjs",
+    "require": "./dist/index.js"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "buildConfig": {
+    "entryPoints": [
+      {
+        "name": "src/index.ts",
+        "target": "node",
+        "bundle": []
+      }
+    ]
+  },
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "abstract-level": "^1.0.4",
+    "date-fns": "^2.30.0",
+    "fast-glob": "^3.3.2",
+    "fs-extra": "^11.2.0",
+    "glob-parent": "^6.0.2",
+    "graphql": "15.8.0",
+    "gray-matter": "^4.0.3",
+    "isomorphic-git": "^1.27.1",
+    "js-sha1": "^0.6.0",
+    "js-yaml": "^3.14.1",
+    "jsonpath-plus": "^6.0.1",
+    "lodash.clonedeep": "^4.5.0",
+    "lodash.set": "^4.3.2",
+    "lodash.uniqby": "^4.7.0",
+    "many-level": "^2.0.0",
+    "micromatch": "4.0.8",
+    "normalize-path": "^3.0.0",
+    "readable-stream": "^4.5.2",
+    "scmp": "^2.1.0",
+    "yup": "^0.32.11",
+    "@tinacms/mdx": "0.0.0-0a77b75-20241004023651",
+    "@tinacms/schema-tools": "0.0.0-0a77b75-20241004023651"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "url": "https://github.com/tinacms/tinacms.git",
+    "directory": "packages/tina-graphql"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/estree": "^0.0.50",
+    "@types/express": "^4.17.21",
+    "@types/fs-extra": "^9.0.13",
+    "@types/jest": "^26.0.24",
+    "@types/js-yaml": "^3.12.10",
+    "@types/lodash.camelcase": "^4.3.9",
+    "@types/lodash.upperfirst": "^4.3.9",
+    "@types/lru-cache": "^5.1.1",
+    "@types/mdast": "^3.0.15",
+    "@types/micromatch": "^4.0.9",
+    "@types/node": "^22.7.4",
+    "@types/normalize-path": "^3.0.2",
+    "@types/ws": "^7.4.7",
+    "@types/yup": "^0.29.14",
+    "jest": "^29.7.0",
+    "jest-diff": "^29.7.0",
+    "jest-file-snapshot": "^0.5.0",
+    "jest-matcher-utils": "^29.7.0",
+    "memory-level": "^1.0.0",
+    "nodemon": "3.1.4",
+    "typescript": "^5.6.2",
+    "@tinacms/schema-tools": "0.0.0-0a77b75-20241004023651",
+    "@tinacms/scripts": "1.2.3"
+  },
+  "scripts": {
+    "types": "pnpm tsc",
+    "build": "tinacms-scripts build",
+    "docs": "pnpm typedoc",
+    "serve": "pnpm nodemon dist/server.js",
+    "test": "jest",
+    "test-watch": "jest --watch"
+  }
+}