@tinacms/graphql 0.0.0-00d7b85-20251222014449

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,3 @@
+import { parseMDX, serializeMDX } from '@tinacms/mdx';
+export { parseMDX };
+export { serializeMDX };

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/auth-fields.d.ts

@@ -0,0 +1,31 @@
+import type { TinaSchema } from '@tinacms/schema-tools';
+import type { GraphQLResolveInfo } from 'graphql';
+import type { Resolver } from './index';
+export declare function handleAuthenticate({ tinaSchema, resolver, sub, password, ctxUser, }: {
+    tinaSchema: TinaSchema;
+    resolver: Resolver;
+    sub?: string;
+    password: string;
+    info: GraphQLResolveInfo;
+    ctxUser?: {
+        sub?: string;
+    };
+}): Promise<any>;
+export declare function handleAuthorize({ tinaSchema, resolver, sub, ctxUser, }: {
+    tinaSchema: TinaSchema;
+    resolver: Resolver;
+    sub?: string;
+    info: GraphQLResolveInfo;
+    ctxUser?: {
+        sub?: string;
+    };
+}): Promise<any>;
+export declare function handleUpdatePassword({ tinaSchema, resolver, password, ctxUser, }: {
+    tinaSchema: TinaSchema;
+    resolver: Resolver;
+    password: string;
+    info: GraphQLResolveInfo;
+    ctxUser?: {
+        sub?: string;
+    };
+}): Promise<boolean>;

package/dist/resolver/error.d.ts

@@ -0,0 +1,39 @@
+/**
+
+*/
+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 = {
+    /** @deprecated */
+    stack?: string;
+    file?: string;
+    includeAuditMessage?: boolean;
+    originalError: Error;
+    collection?: string;
+};
+export declare class TinaFetchError extends Error {
+    collection?: string;
+    file?: string;
+    originalError: Error;
+    constructor(message: string, args: TypeFetchErrorArgs);
+}
+export declare class TinaQueryError extends TinaFetchError {
+    stack?: string;
+    constructor(args: TypeFetchErrorArgs);
+}
+export declare class TinaParseDocumentError extends TinaFetchError {
+    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,387 @@
+/**
+
+*/
+import { Database } from '../database';
+import type { Collectable, Collection, Template, TinaField, 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, hasReferences?: boolean) => Promise<{
+    _sys: {
+        title: any;
+        basename: string;
+        filename: string;
+        extension: string;
+        hasReferences: boolean;
+        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;
+}>;
+/**
+ * Updates a property in an object using a JSONPath.
+ * @param obj - The object to update.
+ * @param path - The JSONPath string.
+ * @param newValue - The new value to set at the specified path.
+ * @returns the updated object.
+ */
+export declare const updateObjectWithJsonPath: (obj: any, path: string, oldValue: any, newValue: any) => {
+    object: any;
+    updated: boolean;
+};
+/**
+ * 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?: import("@tinacms/schema-tools").ContentFormat;
+        ui?: import("@tinacms/schema-tools").UICollection;
+        defaultItem?: import("@tinacms/schema-tools").DefaultItem<Record<string, any>>;
+        frontmatterFormat?: import("@tinacms/schema-tools").ContentFrontmatterFormat;
+        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?: import("@tinacms/schema-tools").ContentFormat;
+        ui?: import("@tinacms/schema-tools").UICollection;
+        defaultItem?: import("@tinacms/schema-tools").DefaultItem<Record<string, any>>;
+        frontmatterFormat?: import("@tinacms/schema-tools").ContentFrontmatterFormat;
+        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;
+            hasReferences: boolean;
+            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, opts?: {
+        collection?: Collection<true>;
+        checkReferences?: boolean;
+    }) => Promise<{
+        _sys: {
+            title: any;
+            basename: string;
+            filename: string;
+            extension: string;
+            hasReferences: boolean;
+            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;
+            hasReferences: boolean;
+            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;
+            hasReferences: boolean;
+            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;
+            hasReferences: boolean;
+            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;
+                    hasReferences: boolean;
+                    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;
+        };
+    }>;
+    /**
+     * Checks if a document has references to it
+     * @param id  The id of the document to check for references
+     * @param c The collection to check for references
+     * @returns true if the document has references, false otherwise
+     */
+    private hasReferences;
+    /**
+     * Finds references to a document
+     * @param id the id of the document to find references to
+     * @param c the collection to find references in
+     * @returns a map of references to the document
+     */
+    private findReferences;
+    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 { Schema } from '@tinacms/schema-tools';
+import type { GraphQLConfig } from '../types';
+/**
+ * Strips away the TinaCloud 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 TinaCloud 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,5 @@
+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,8 @@
+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;