@tinacms/graphql 0.0.0-00d7b85-20251222014449

package/dist/builder/index.d.ts

@@ -0,0 +1,268 @@
+/**
+
+*/
+import { LookupMapType } from '../database';
+import type { FieldDefinitionNode, InlineFragmentNode, ObjectTypeDefinitionNode } from 'graphql';
+import type { Collection, Template } from '@tinacms/schema-tools';
+import { TinaSchema } from '@tinacms/schema-tools';
+export declare const createBuilder: ({ tinaSchema, }: {
+    tinaSchema: TinaSchema;
+}) => Promise<Builder>;
+/**
+ * The builder class is responsible for creating GraphQL AST definitions
+ * for a given portion of the Tina schema. In some cases that will also mean
+ * storing a reference to how we can resolve that type when we come across it.
+ */
+export declare class Builder {
+    config: {
+        tinaSchema: TinaSchema;
+    };
+    private maxDepth;
+    tinaSchema: TinaSchema;
+    lookupMap: Record<string, LookupMapType>;
+    constructor(config: {
+        tinaSchema: TinaSchema;
+    });
+    private addToLookupMap;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   getCollection(collection: $collection) {
+     *     name
+     *     documents {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
+    buildCollectionDefinition: (collections: Collection<true>[]) => Promise<FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   getCollections {
+     *     name
+     *     documents {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
+    buildMultiCollectionDefinition: (collections: Collection<true>[]) => Promise<FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   node(id: $id) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     */
+    multiNodeDocument: () => Promise<FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   getDocument(collection: $collection, relativePath: $relativePath) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
+    multiCollectionDocument: (collections: Collection<true>[]) => Promise<FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   addPendingDocument(collection: $collection, relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
+    addMultiCollectionDocumentMutation: () => Promise<FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   createDocument(relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
+    buildCreateCollectionDocumentMutation: (collections: Collection<true>[]) => Promise<FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   updateDocument(relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
+    buildUpdateCollectionDocumentMutation: (collections: Collection<true>[]) => Promise<FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   deleteDocument(relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
+    buildDeleteCollectionDocumentMutation: (collections: Collection<true>[]) => Promise<FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   createFolder(folderName: $folderName, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
+    buildCreateCollectionFolderMutation: () => Promise<FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   getPostDocument(relativePath: $relativePath) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collection
+     */
+    collectionDocument: (collection: Collection<true>) => Promise<FieldDefinitionNode>;
+    authenticationCollectionDocument: (collection: Collection<true>) => Promise<FieldDefinitionNode>;
+    updatePasswordMutation: (collection: Collection<true>) => Promise<FieldDefinitionNode>;
+    authorizationCollectionDocument: (collection: Collection<true>) => Promise<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 TinaCloud collection
+     */
+    collectionFragment: (collection: Collection<true>) => Promise<import("graphql").FragmentDefinitionNode>;
+    /**
+     * Given a collection this function returns its selections set. For example for Post this would return
+     *
+     * "
+     * body
+     * title
+     * ... on Author {
+     *   name
+     *   heroImg
+     * }
+     *
+     * But in the AST format
+     *
+     * */
+    private _getCollectionFragmentSelections;
+    private _buildFieldNodeForFragments;
+    buildTemplateFragments(template: Template<true>, depth: number): Promise<InlineFragmentNode | boolean>;
+    /**
+     * ```graphql
+     * # ex.
+     * mutation {
+     *   updatePostDocument(relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collection
+     */
+    updateCollectionDocumentMutation: (collection: Collection<true>) => Promise<FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * mutation {
+     *   createPostDocument(relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collection
+     */
+    createCollectionDocumentMutation: (collection: Collection<true>) => Promise<FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   getPostList(first: 10) {
+     *     edges {
+     *       node {
+     *         id
+     *       }
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * @param collection
+     */
+    collectionDocumentList: (collection: Collection<true>) => Promise<FieldDefinitionNode>;
+    /**
+     * GraphQL type definitions which remain unchanged regardless
+     * of the supplied Tina schema. Ex. "node" interface
+     */
+    buildStaticDefinitions: () => (import("graphql").ScalarTypeDefinitionNode | ObjectTypeDefinitionNode | import("graphql").InterfaceTypeDefinitionNode[])[];
+    private _buildCollectionDocumentType;
+    private _buildAuthDocumentType;
+    private _filterCollectionDocumentType;
+    private _buildTemplateFilter;
+    private _updateCollectionDocumentMutationType;
+    private _buildTemplateMutation;
+    private _buildMultiCollectionDocumentDefinition;
+    private _buildMultiCollectionDocumentListDefinition;
+    private _buildFieldFilter;
+    private _buildFieldMutation;
+    private _buildReferenceMutation;
+    private _buildPasswordMutation;
+    private _buildUpdateDocumentMutationParams;
+    private _buildObjectOrUnionData;
+    private _connectionFilterBuilder;
+    private _connectionFieldBuilder;
+    private _buildDataField;
+    private _buildTemplateData;
+}

package/dist/builder/static-definitions.d.ts

@@ -0,0 +1,4 @@
+/**
+
+*/
+export declare const staticDefinitions: (import("graphql").ScalarTypeDefinitionNode | import("graphql").ObjectTypeDefinitionNode | import("graphql").InterfaceTypeDefinitionNode[])[];

package/dist/database/alias-utils.d.ts

@@ -0,0 +1,3 @@
+import { Template } from '@tinacms/schema-tools';
+export declare const replaceNameOverrides: (template: Template, obj: any) => object;
+export declare const applyNameOverrides: (template: Template, obj: any) => object;

package/dist/database/bridge/filesystem.d.ts

@@ -0,0 +1,21 @@
+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
+ * for GitHub has well.
+ */
+export declare class FilesystemBridge implements Bridge {
+    rootPath: string;
+    outputPath: string;
+    constructor(rootPath: string, outputPath?: string);
+    glob(pattern: string, extension: string): Promise<string[]>;
+    delete(filepath: string): Promise<void>;
+    get(filepath: string): Promise<string>;
+    put(filepath: string, data: string, basePathOverride?: string): Promise<void>;
+}
+/**
+ * Same as the `FileSystemBridge` except it does not save files
+ */
+export declare class AuditFileSystemBridge extends FilesystemBridge {
+    put(filepath: string, data: string): Promise<void>;
+}

package/dist/database/bridge/index.d.ts

@@ -0,0 +1,12 @@
+export interface Bridge {
+    rootPath: string;
+    glob(pattern: string, extension: string): Promise<string[]>;
+    delete(filepath: string): Promise<void>;
+    get(filepath: string): Promise<string>;
+    put(filepath: string, data: string): Promise<void>;
+    /**
+     * Optionally, the bridge can perform
+     * operations in a separate path.
+     */
+    outputPath?: string;
+}

package/dist/database/bridge/isomorphic.d.ts

@@ -0,0 +1,94 @@
+import { CallbackFsClient, PromiseFsClient } from 'isomorphic-git';
+import type { Bridge } from './index';
+export type IsomorphicGitBridgeOptions = {
+    gitRoot: string;
+    fsModule?: CallbackFsClient | PromiseFsClient;
+    commitMessage?: string;
+    author: {
+        name: string;
+        email: string;
+    };
+    committer?: {
+        name: string;
+        email: string;
+    };
+    ref?: string;
+    onPut?: (filepath: string, data: string) => Promise<void>;
+    onDelete?: (filepath: string) => Promise<void>;
+};
+/**
+ * Bridge backed by isomorphic-git
+ */
+export declare class IsomorphicBridge implements Bridge {
+    rootPath: string;
+    relativePath: string;
+    gitRoot: string;
+    fsModule: CallbackFsClient | PromiseFsClient;
+    isomorphicConfig: {
+        fs: CallbackFsClient | PromiseFsClient;
+        dir: string;
+    };
+    commitMessage: string;
+    author: {
+        name: string;
+        email: string;
+    };
+    committer: {
+        name: string;
+        email: string;
+    };
+    ref: string | undefined;
+    private readonly onPut;
+    private readonly onDelete;
+    private cache;
+    constructor(rootPath: string, { gitRoot, author, committer, fsModule, commitMessage, ref, onPut, onDelete, }: IsomorphicGitBridgeOptions);
+    private getAuthor;
+    private getCommitter;
+    /**
+     * Recursively populate paths matching `pattern` for the given `entry`
+     *
+     * @param pattern - pattern to filter paths by
+     * @param entry - TreeEntry to start building list from
+     * @param path - base path
+     * @param results
+     * @private
+     */
+    private listEntries;
+    /**
+     * For the specified path, returns an object with an array containing the parts of the path (pathParts)
+     * and an array containing the WalkerEntry objects for the path parts (pathEntries). Any null elements in the
+     * pathEntries are placeholders for non-existent entries.
+     *
+     * @param path - path being resolved
+     * @param ref - ref to resolve path entries for
+     * @private
+     */
+    private resolvePathEntries;
+    /**
+     * Updates tree entry and associated parent tree entries
+     *
+     * @param existingOid - the existing OID
+     * @param updatedOid - the updated OID
+     * @param path - the path of the entry being updated
+     * @param type - the type of the entry being updated (blob or tree)
+     * @param pathEntries - parent path entries
+     * @param pathParts - parent path parts
+     * @private
+     */
+    private updateTreeHierarchy;
+    /**
+     * Creates a commit for the specified tree and updates the specified ref to point to the commit
+     *
+     * @param treeSha - sha of the new tree
+     * @param ref - the ref that should be updated
+     * @private
+     */
+    private commitTree;
+    private getRef;
+    glob(pattern: string, extension: string): Promise<string[]>;
+    delete(filepath: string): Promise<void>;
+    private qualifyPath;
+    private unqualifyPath;
+    get(filepath: string): Promise<string>;
+    put(filepath: string, data: string): Promise<void>;
+}

package/dist/database/datalayer.d.ts

@@ -0,0 +1,80 @@
+/**
+
+*/
+import { BatchOp, Level } from './level';
+import type { Collection } from '@tinacms/schema-tools';
+export declare enum OP {
+    EQ = "eq",
+    GT = "gt",
+    LT = "lt",
+    GTE = "gte",
+    LTE = "lte",
+    STARTS_WITH = "startsWith",
+    IN = "in"
+}
+export type BinaryFilter = {
+    pathExpression: string;
+    rightOperand: FilterOperand;
+    operator: OP.EQ | OP.GT | OP.LT | OP.GTE | OP.LTE | OP.STARTS_WITH | OP.IN;
+    type: string;
+    pad?: PadDefinition;
+    list: boolean;
+};
+export type TernaryFilter = {
+    pathExpression: string;
+    leftOperand: FilterOperand;
+    rightOperand: FilterOperand;
+    leftOperator: OP.GTE | OP.GT;
+    rightOperator: OP.LT | OP.LTE;
+    type: string;
+    pad?: PadDefinition;
+    list: boolean;
+};
+export type IndexDefinition = {
+    fields: {
+        name: string;
+        type?: string;
+        pad?: PadDefinition;
+        list: boolean;
+    }[];
+};
+export type PadDefinition = {
+    fillString: string;
+    maxLength: number;
+};
+export type FilterOperand = string | number | boolean | string[] | number[];
+export type FilterCondition = {
+    filterExpression: Record<string, FilterOperand>;
+    filterPath: string;
+};
+type StringEscaper = <T extends string | string[]>(input: T) => T;
+export declare const DEFAULT_COLLECTION_SORT_KEY = "__filepath__";
+export declare const REFS_COLLECTIONS_SORT_KEY = "__refs__";
+export declare const REFS_REFERENCE_FIELD = "__tina_ref__";
+export declare const REFS_PATH_FIELD = "__tina_ref_path__";
+export declare const DEFAULT_NUMERIC_LPAD = 4;
+export declare const coerceFilterChainOperands: (filterChain: (BinaryFilter | TernaryFilter)[], escapeString?: StringEscaper) => (BinaryFilter | TernaryFilter)[];
+export declare const makeFilter: ({ filterChain, }: {
+    filterChain?: (BinaryFilter | TernaryFilter)[];
+}) => ((values: Record<string, object | FilterOperand>) => boolean);
+export declare const makeFilterChain: ({ conditions, }: {
+    conditions: FilterCondition[];
+}) => (BinaryFilter | TernaryFilter)[];
+export declare const makeFilterSuffixes: (filterChain: (BinaryFilter | TernaryFilter)[], index: IndexDefinition) => {
+    left?: string;
+    right?: string;
+} | undefined;
+export declare const FOLDER_ROOT = "~";
+type FolderTree = Record<string, Set<string>>;
+export declare class FolderTreeBuilder {
+    _tree: FolderTree;
+    constructor();
+    get tree(): FolderTree;
+    update(documentPath: string, collectionPath: string): any;
+}
+export declare const makeFolderOpsForCollection: <T extends object>(folderTree: FolderTree, collection: Collection<true>, indexDefinitions: Record<string, IndexDefinition>, opType: "put" | "del", level: Level, escapeStr?: StringEscaper) => BatchOp[];
+export declare const makeIndexOpsForDocument: <T extends object>(filepath: string, collection: string | undefined, indexDefinitions: Record<string, IndexDefinition>, data: T, opType: "put" | "del", level: Level, escapeStr?: StringEscaper) => BatchOp[];
+export declare const makeRefOpsForDocument: <T extends object>(filepath: string, collection: string | undefined, references: Record<string, string[]> | undefined | null, data: T, opType: "put" | "del", level: Level) => BatchOp[];
+export declare const makeStringEscaper: (regex: RegExp, replacement: string) => StringEscaper;
+export declare const stringEscaper: StringEscaper;
+export {};

package/dist/database/index.d.ts

@@ -0,0 +1,203 @@
+import type { DocumentNode } from 'graphql';
+import type { Collection, CollectionTemplateable, Schema, TinaSchema } from '@tinacms/schema-tools';
+import type { Bridge } from './bridge';
+import { type BinaryFilter, type IndexDefinition, type TernaryFilter } from './datalayer';
+import { type Level } from './level';
+type IndexStatusEvent = {
+    status: 'inprogress' | 'complete' | 'failed';
+    error?: Error;
+};
+type IndexStatusCallback = (event: IndexStatusEvent) => Promise<void>;
+export type OnPutCallback = (key: string, value: any) => Promise<void>;
+export type OnDeleteCallback = (key: string) => Promise<void>;
+export interface DatabaseArgs {
+    bridge?: Bridge;
+    level: Level;
+    onPut?: (key: string, value: any) => Promise<void>;
+    onDelete?: (key: string) => Promise<void>;
+    tinaDirectory?: string;
+    indexStatusCallback?: IndexStatusCallback;
+    version?: boolean;
+    namespace?: string;
+}
+export interface GitProvider {
+    onPut: (key: string, value: string) => Promise<void>;
+    onDelete: (key: string) => Promise<void>;
+}
+export type CreateDatabase = Omit<DatabaseArgs, 'level' | 'onPut' | 'onDelete'> & {
+    databaseAdapter: Level;
+    gitProvider: GitProvider;
+    /**
+     * @deprecated Use databaseAdapter instead
+     */
+    level?: Level;
+    /**
+     * @deprecated Use gitProvider instead
+     */
+    onPut?: OnPutCallback;
+    /**
+     * @deprecated Use gitProvider instead
+     */
+    onDelete?: OnDeleteCallback;
+};
+export type CreateLocalDatabaseArgs = Omit<DatabaseArgs, 'level'> & {
+    port?: number;
+    rootPath?: string;
+};
+export declare const createLocalDatabase: (config?: CreateLocalDatabaseArgs) => Database;
+export declare const createDatabase: (config: CreateDatabase) => Database;
+export declare const createDatabaseInternal: (config: DatabaseArgs) => Database;
+/** Options for {@link Database.query} **/
+export type QueryOptions = {
+    fileExtension?: string;
+    collection: string;
+    filterChain?: (BinaryFilter | TernaryFilter)[];
+    sort?: string;
+    first?: number;
+    last?: number;
+    after?: string;
+    before?: string;
+    folder?: string;
+};
+export declare class Database {
+    config: DatabaseArgs;
+    bridge?: Bridge;
+    rootLevel: Level;
+    appLevel: Level | undefined;
+    contentLevel: Level | undefined;
+    tinaDirectory: string;
+    indexStatusCallback: IndexStatusCallback | undefined;
+    private readonly onPut;
+    private readonly onDelete;
+    private tinaSchema;
+    private contentNamespace;
+    private collectionIndexDefinitions;
+    private collectionReferences;
+    private _lookup;
+    constructor(config: DatabaseArgs);
+    private collectionForPath;
+    private getGeneratedFolder;
+    private updateDatabaseVersion;
+    private getDatabaseVersion;
+    private initLevel;
+    getMetadata: (key: string) => Promise<any>;
+    setMetadata: (key: string, value: string) => Promise<void>;
+    get: <T extends object>(filepath: string) => Promise<T>;
+    addPendingDocument: (filepath: string, data: {
+        [key: string]: unknown;
+    }) => Promise<void>;
+    put: (filepath: string, data: {
+        [key: string]: unknown;
+    }, collectionName?: string) => Promise<boolean>;
+    getTemplateDetailsForFile(collection: Collection<true>, data: {
+        [key: string]: unknown;
+    }): Promise<{
+        template: {
+            label?: string | boolean;
+            name: string;
+            nameOverride?: string;
+            ui?: {
+                itemProps?(item: Record<string, any>): {
+                    key?: string;
+                    label?: string | boolean;
+                };
+                defaultItem?: import("@tinacms/schema-tools").DefaultItem<Record<string, any>>;
+                previewSrc?: string;
+            };
+            fields: ((import("@tinacms/schema-tools").StringField | import("@tinacms/schema-tools").NumberField | import("@tinacms/schema-tools").BooleanField | import("@tinacms/schema-tools").DateTimeField | import("@tinacms/schema-tools").ImageField | import("@tinacms/schema-tools").ReferenceField | import("@tinacms/schema-tools").PasswordField | import("@tinacms/schema-tools").RichTextField<false> | import("@tinacms/schema-tools").ObjectField<false>) & {})[];
+        };
+        info: CollectionTemplateable;
+    }>;
+    formatBodyOnPayload: (filepath: string, data: {
+        [key: string]: unknown;
+    }) => Promise<{
+        [key: string]: unknown;
+    }>;
+    stringifyFile: (filepath: string, payload: {
+        [key: string]: unknown;
+    }, collection: Collection<true>) => Promise<string>;
+    /**
+     * Clears the internal cache of the tinaSchema and the lookup file. This allows the state to be reset
+     */
+    clearCache(): void;
+    flush: (filepath: string) => Promise<string>;
+    getLookup: (returnType?: string) => Promise<LookupMapType | Record<string, LookupMapType>>;
+    getGraphQLSchema: () => Promise<DocumentNode>;
+    getGraphQLSchemaFromBridge: () => Promise<DocumentNode>;
+    getTinaSchema: (level?: Level) => Promise<Schema>;
+    getSchema: (level?: Level, existingSchema?: Schema) => Promise<TinaSchema>;
+    getCollectionReferences: (level?: Level) => Promise<Record<string, Record<string, string[]>>>;
+    getIndexDefinitions: (level?: Level) => Promise<Record<string, Record<string, IndexDefinition>>>;
+    documentExists: (fullpath: unknown) => Promise<boolean>;
+    query: (queryOptions: QueryOptions, hydrator: any) => Promise<{
+        edges: {
+            node: any;
+            cursor: string;
+        }[];
+        pageInfo: {
+            hasPreviousPage: boolean;
+            hasNextPage: boolean;
+            startCursor: string;
+            endCursor: string;
+        };
+    }>;
+    private indexStatusCallbackWrapper;
+    indexContent: ({ graphQLSchema, tinaSchema, lookup: lookupFromLockFile, }: {
+        graphQLSchema: DocumentNode;
+        tinaSchema: TinaSchema;
+        lookup?: object;
+    }) => Promise<{
+        warnings: string[];
+    }>;
+    deleteContentByPaths: (documentPaths: string[]) => Promise<void>;
+    indexContentByPaths: (documentPaths: string[]) => Promise<void>;
+    delete: (filepath: string) => Promise<void>;
+    _indexAllContent: (level: Level, schema?: Schema) => Promise<{
+        warnings: string[];
+    }>;
+}
+export type LookupMapType = GlobalDocumentLookup | CollectionDocumentLookup | CollectionFolderLookup | MultiCollectionDocumentLookup | MultiCollectionDocumentListLookup | CollectionDocumentListLookup | UnionDataLookup | NodeDocument;
+type NodeDocument = {
+    type: string;
+    resolveType: 'nodeDocument';
+};
+type GlobalDocumentLookup = {
+    type: string;
+    resolveType: 'globalDocument';
+    collection: string;
+};
+type CollectionDocumentLookup = {
+    type: string;
+    resolveType: 'collectionDocument';
+    collection: string;
+};
+type CollectionFolderLookup = {
+    type: string;
+    resolveType: 'collectionFolder';
+    collection: string;
+};
+type MultiCollectionDocumentLookup = {
+    type: string;
+    resolveType: 'multiCollectionDocument';
+    createDocument: 'create';
+    updateDocument: 'update';
+};
+type MultiCollectionDocumentListLookup = {
+    type: string;
+    resolveType: 'multiCollectionDocumentList';
+    collections: string[];
+};
+export type CollectionDocumentListLookup = {
+    type: string;
+    resolveType: 'collectionDocumentList';
+    collection: string;
+};
+type UnionDataLookup = {
+    type: string;
+    resolveType: 'unionData';
+    collection?: string;
+    typeMap: {
+        [templateName: string]: string;
+    };
+};
+export {};