@tinacms/graphql 0.0.0-0a77b75-20241004023651

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,76 @@
+/**
+
+*/
+import { BatchOp, Level } from './level';
+import { 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 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 makeStringEscaper: (regex: RegExp, replacement: string) => StringEscaper;
+export declare const stringEscaper: StringEscaper;
+export {};

package/dist/database/index.d.ts

@@ -0,0 +1,201 @@
+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 _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>;
+    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 {};

package/dist/database/level.d.ts

@@ -0,0 +1,28 @@
+/**
+
+*/
+import { AbstractLevel, AbstractSublevel, AbstractSublevelOptions } from 'abstract-level';
+export type Level = AbstractLevel<Buffer | Uint8Array | string, string, Record<string, any>>;
+export type PutOp = {
+    type: 'put';
+    key: string;
+    value: Record<string, any>;
+    sublevel?: AbstractSublevel<Level, Buffer | Uint8Array | string, string, Record<string, any>>;
+};
+export type DelOp = {
+    type: 'del';
+    key: string;
+    sublevel?: AbstractSublevel<Level, Buffer | Uint8Array | string, string, Record<string, Record<string, any>>>;
+};
+export type BatchOp = PutOp | DelOp;
+export declare const ARRAY_ITEM_VALUE_SEPARATOR = ",";
+export declare const INDEX_KEY_FIELD_SEPARATOR = "\u001D";
+export declare const CONTENT_ROOT_PREFIX = "~";
+export declare const SUBLEVEL_OPTIONS: AbstractSublevelOptions<string, Record<string, any>>;
+export declare class LevelWrapper {
+    private level;
+    constructor(level: Level);
+}
+export declare class LevelProxy {
+    constructor(level: Level);
+}

package/dist/database/util.d.ts

@@ -0,0 +1,33 @@
+/**
+
+*/
+import * as yup from 'yup';
+import { Collection, CollectionTemplateable, normalizePath, TinaSchema } from '@tinacms/schema-tools';
+import { Bridge } from './bridge';
+export { normalizePath };
+export declare const stringifyFile: (content: object, format: FormatType | string, keepTemplateKey: boolean, markdownParseConfig?: {
+    frontmatterFormat?: "toml" | "yaml" | "json";
+    frontmatterDelimiters?: [string, string] | string;
+}) => string;
+export declare const parseFile: <T extends object>(content: string, format: FormatType | string, yupSchema: (args: typeof yup) => yup.ObjectSchema<any>, markdownParseConfig?: {
+    frontmatterFormat?: "toml" | "yaml" | "json";
+    frontmatterDelimiters?: [string, string] | string;
+}) => T;
+export type FormatType = 'json' | 'md' | 'mdx' | 'markdown';
+export declare const atob: (b64Encoded: string) => string;
+export declare const btoa: (string: string) => string;
+export declare const scanAllContent: (tinaSchema: TinaSchema, bridge: Bridge, callback: (collection: Collection<true>, contentPaths: string[]) => Promise<void>) => Promise<string[]>;
+export declare const scanContentByPaths: (tinaSchema: TinaSchema, documentPaths: string[], callback: (collection: Collection<true> | undefined, documentPaths: string[]) => Promise<void>) => Promise<void>;
+export declare const partitionPathsByCollection: (tinaSchema: TinaSchema, documentPaths: string[]) => Promise<{
+    pathsByCollection: Record<string, string[]>;
+    nonCollectionPaths: string[];
+    collections: Record<string, Collection<true>>;
+}>;
+/** TODO help needed with name of this function **/
+export declare const transformDocument: <T extends object>(filepath: string, contentObject: any, tinaSchema: TinaSchema) => T;
+export declare function hasOwnProperty<X extends {}, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown>;
+export declare const getTemplateForFile: (templateInfo: CollectionTemplateable, data: {
+    [key: string]: unknown;
+}) => import("@tinacms/schema-tools").Template<true>;
+/** TODO help needed with name of this function **/
+export declare const loadAndParseWithAliases: (bridge: Bridge, filepath: string, collection?: Collection<true>, templateInfo?: CollectionTemplateable) => Promise<object>;

package/dist/error.d.ts

@@ -0,0 +1,4 @@
+import { ASTNode, GraphQLError, GraphQLErrorExtensions, Source } from 'graphql';
+export declare class NotFoundError extends GraphQLError {
+    constructor(message: string, nodes?: ASTNode | readonly ASTNode[], source?: Source, positions?: readonly number[], path?: readonly (string | number)[], originalError?: Error, extensions?: GraphQLErrorExtensions);
+}

package/dist/git/index.d.ts

@@ -0,0 +1,23 @@
+import { CallbackFsClient, PromiseFsClient } from 'isomorphic-git';
+export declare const getSha: ({ fs, dir, }: {
+    fs: CallbackFsClient | PromiseFsClient;
+    dir: string;
+}) => Promise<string>;
+export declare const getChangedFiles: ({ fs, dir, from, to, pathFilter, }: {
+    fs: CallbackFsClient | PromiseFsClient;
+    dir: string;
+    from: string;
+    to: string;
+    pathFilter: Record<string, {
+        matches?: string[];
+    }>;
+}) => Promise<{
+    added: any[];
+    modified: any[];
+    deleted: any[];
+}>;
+export declare const shaExists: ({ fs, dir, sha, }: {
+    fs: CallbackFsClient | PromiseFsClient;
+    dir: string;
+    sha: string;
+}) => Promise<boolean>;

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import type { Schema, Collection, Template as TinaTemplate } from '@tinacms/schema-tools';
+import { buildDotTinaFiles } from './build';
+export { resolve } from './resolve';
+export { transformDocumentIntoPayload } from './resolver';
+export * from './resolver/error';
+export { TinaLevelClient } from './level/tinaLevel';
+export type { Level } from './database/level';
+export type { QueryOptions, OnDeleteCallback, OnPutCallback, DatabaseArgs, GitProvider, CreateDatabase, } from './database';
+export { Database, createDatabaseInternal, createDatabase, createLocalDatabase, } from './database';
+import type { Config } from '@tinacms/schema-tools';
+export { getChangedFiles, getSha, shaExists } from './git';
+export * from './auth/utils';
+export { sequential, assertShape } from './util';
+export { loadAndParseWithAliases, stringifyFile, parseFile, scanAllContent, scanContentByPaths, transformDocument, } from './database/util';
+export { createSchema } from './schema/createSchema';
+export { buildDotTinaFiles };
+export type DummyType = unknown;
+export declare const buildSchema: (config: Config, flags?: string[]) => Promise<{
+    graphQLSchema: {
+        kind: "Document";
+        definitions: any;
+    };
+    tinaSchema: import("@tinacms/schema-tools").TinaSchema;
+    lookup: Record<string, import("./database").LookupMapType>;
+    fragDoc: string;
+    queryDoc: string;
+}>;
+export type TinaSchema = Schema;
+export type { TinaTemplate, Schema, Collection };
+export { FilesystemBridge, AuditFileSystemBridge, } from './database/bridge/filesystem';
+export { IsomorphicBridge } from './database/bridge/isomorphic';
+export type { Bridge } from './database/bridge';