@tinacms/datalayer 0.0.2 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,59 @@
 # tina-graphql
 
+## 0.2.0
+
+### Minor Changes
+
+- 4daf15b36: Updated matching logic to only return the correct extension.
+
+  This means if you are using any other files besides `.md` the format must be provided in the schema.
+
+  ```ts
+  // .tina/schema.ts
+
+  import { defineSchema } from 'tinacms'
+
+  const schema = defineSchema({
+    collections: [
+      {
+        name: 'page',
+        path: 'content/page',
+        label: 'Page',
+        // Need to provide the format if the file being used (default is `.md`)
+        format: 'mdx',
+        fields: [
+          //...
+        ],
+      },
+    ],
+  })
+  //...
+
+  export default schema
+  ```
+
+### Patch Changes
+
+- b348f8b6b: Experimental isomorphic git bridge implementation
+
+## 0.1.1
+
+### Patch Changes
+
+- a2906d6fe: Fix datetime filtering to handle both indexed and non-indexed queries
+- 3e2d9e43a: Adds new GraphQL `deleteDocument` mutation and logic
+
+## 0.1.0
+
+### Minor Changes
+
+- a87e1e6fa: Enable query filtering, pagination, sorting
+
+### Patch Changes
+
+- 8b3be903f: Escape index field separator in input strings
+- b01f2e382: Fixed an issue where `0` as a numerical operand was being evaluated as falsy.
+
 ## 0.0.2
 
 ### Patch Changes

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

@@ -19,8 +19,9 @@ import type { Bridge } from './index';
 export declare class FilesystemBridge implements Bridge {
     rootPath: string;
     constructor(rootPath: string);
-    glob(pattern: string): Promise<string[]>;
+    glob(pattern: string, extension: string): Promise<string[]>;
     supportsBuilding(): boolean;
+    delete(filepath: string): Promise<void>;
     get(filepath: string): Promise<string>;
     putConfig(filepath: string, data: string): Promise<void>;
     put(filepath: string, data: string): Promise<void>;

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

@@ -12,7 +12,8 @@ limitations under the License.
 */
 export interface Bridge {
     rootPath: string;
-    glob(pattern: string): Promise<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>;
     /**

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

@@ -0,0 +1,108 @@
+/**
+ 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 { CallbackFsClient, PromiseFsClient } from 'isomorphic-git';
+import type { Bridge } from './index';
+export declare 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[]>;
+    supportsBuilding(): boolean;
+    delete(filepath: string): Promise<void>;
+    private qualifyPath;
+    private unqualifyPath;
+    get(filepath: string): Promise<string>;
+    putConfig(filepath: string, data: string): Promise<void>;
+    put(filepath: string, data: string): Promise<void>;
+}

package/dist/database/store/filesystem.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 { Store } from '.';
+import { StoreQueryOptions, PutOptions, Store, StoreQueryResponse } from '.';
 export declare class FilesystemStore implements Store {
     rootPath: string;
     clear(): Promise<void>;
@@ -18,13 +18,16 @@ export declare class FilesystemStore implements Store {
     constructor({ rootPath }: {
         rootPath?: string;
     });
-    query(queryStrings: string[]): Promise<object[]>;
+    query(_queryOptions: StoreQueryOptions): Promise<StoreQueryResponse>;
     seed(): Promise<void>;
     get<T extends object>(filepath: string): Promise<T>;
     supportsSeeding(): boolean;
     supportsIndexing(): boolean;
-    glob(pattern: string, callback: any): Promise<any[]>;
-    put(filepath: string, data: object, keepTemplateKey: boolean): Promise<void>;
+    glob(pattern: string, callback: any, extension: any): Promise<any[]>;
+    put(filepath: string, data: object, options?: PutOptions): Promise<void>;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    delete(filepath: any): Promise<void>;
 }
 export declare class AuditFilesystemStore extends FilesystemStore {
     put(_filepath: string, _data: object): Promise<void>;

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

@@ -10,42 +10,97 @@ 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 { FilterOperand } from '../../index';
+export declare const DEFAULT_COLLECTION_SORT_KEY = "__filepath__";
+export declare const INDEX_KEY_FIELD_SEPARATOR = "#";
+export declare const DEFAULT_NUMERIC_LPAD = 4;
+export declare enum OP {
+    EQ = "eq",
+    GT = "gt",
+    LT = "lt",
+    GTE = "gte",
+    LTE = "lte",
+    STARTS_WITH = "startsWith",
+    IN = "in"
+}
+export declare type PadDefinition = {
+    fillString: string;
+    maxLength: number;
+};
+export declare 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;
+};
+export declare type TernaryFilter = {
+    pathExpression: string;
+    leftOperand: FilterOperand;
+    rightOperand: FilterOperand;
+    leftOperator: OP.GTE | OP.GT;
+    rightOperator: OP.LT | OP.LTE;
+    type: string;
+    pad?: PadDefinition;
+};
+/** Options for {@link Store.query} */
+export declare type StoreQueryOptions = {
+    collection: string;
+    indexDefinitions?: Record<string, IndexDefinition>;
+    filterChain: (BinaryFilter | TernaryFilter)[];
+    sort?: string;
+    gt?: string;
+    gte?: string;
+    lt?: string;
+    lte?: string;
+    reverse?: boolean;
+    limit?: number;
+};
+export declare type PageInfo = {
+    hasPreviousPage: boolean;
+    hasNextPage: boolean;
+    startCursor: string;
+    endCursor: string;
+};
+export declare type StoreQueryResponse = {
+    edges: {
+        cursor: string;
+        path: string;
+    }[];
+    pageInfo: PageInfo;
+};
+export declare type IndexDefinition = {
+    fields: {
+        name: string;
+        type?: string;
+        pad?: PadDefinition;
+    }[];
+};
+export declare type SeedOptions = {
+    collection?: string;
+    indexDefinitions?: Record<string, IndexDefinition>;
+    includeTemplate?: boolean;
+    keepTemplateKey?: boolean;
+};
+export declare type PutOptions = SeedOptions & {
+    seed?: boolean;
+};
+export declare type DeleteOptions = SeedOptions & {
+    seed?: boolean;
+};
 export interface Store {
-    glob(pattern: string, hydrator?: (fullPath: string) => Promise<object>): Promise<string[]>;
+    glob(pattern: string, hydrator?: (fullPath: string) => Promise<object>, extension?: string): Promise<string[]>;
     get<T extends object>(filepath: string): Promise<T>;
+    delete(filepath: string, options?: DeleteOptions): Promise<void>;
     clear(): void;
+    close(): void;
+    open(): void;
     /**
-     *
-     * @param queryStrings
-     * Queries are currently structured as prefixed keys where that last portion
-     * of the key is the value provided by the query
-     * ```graphql
-     * {
-     *   getPostsList(filter: {
-     *     title: {
-     *       eq: "Hello, World"
-     *     }
-     *   }) {
-     *      ...
-     *   }
-     * }
-     * ```
-     * Would equate to a query string of:
-     * ```
-     * __attribute__#posts#posts#title#Hello, World
-     * ```
-     * This can be used by a data store as a secondary index of sorts
-     *
-     * It's important to note that for now each query string acts as an "AND" clause,
-     * meaning the resulting records need to be present in _each_ query string.
-     *
-     * @param hydrator
-     * hydrator is an optional callback, which may be useful depending on the storage mechanism.
-     * For example, the in-memory storage only stores the path to its records as its value,
-     * but in something like DynamoDB the query strings may be used to look up the full record,
-     * meaning there's no need to "hydrate" the return value
+     * Executes a query against a collection
+     * @param queryOptions - options for the query
+     * @returns the results of the query
      */
-    query(queryStrings: string[], hydrator?: (fullPath: string) => Promise<object>): Promise<object[]>;
+    query(queryOptions: StoreQueryOptions): Promise<StoreQueryResponse>;
     /**
      * In this context, seeding is the act of putting records and indexing data into an ephemeral
      * storage layer for use during the GraphQL runtime. What might seem suprising is that some stores
@@ -56,9 +111,7 @@ export interface Store {
      * At this time it seems that it would never make sense to be able to "query" without "seed"-ing, and
      * there'd be no value in "seeding" without "query"-ing.
      */
-    seed(filepath: string, data: object, options?: {
-        includeTemplate?: boolean;
-    }): Promise<void>;
+    seed(filepath: string, data: object, options?: PutOptions): Promise<void>;
     supportsSeeding(): boolean;
     /**
      * Whether this store supports the ability to index data.
@@ -68,5 +121,24 @@ export interface Store {
      * user's repo.
      */
     supportsIndexing(): boolean;
-    put(filepath: string, data: object, keepTemplateKey: boolean): Promise<void>;
+    put(filepath: string, data: object, options?: PutOptions): Promise<void>;
 }
+export declare type FilterCondition = {
+    filterExpression: Record<string, FilterOperand>;
+    filterPath: string;
+};
+export declare const makeFilterChain: ({ conditions, }: {
+    conditions: FilterCondition[];
+}) => (BinaryFilter | TernaryFilter)[];
+export declare const makeFilter: ({ filterChain, }: {
+    filterChain?: (BinaryFilter | TernaryFilter)[];
+}) => (values: Record<string, object | FilterOperand>) => boolean;
+declare type StringEscaper = <T extends string | string[]>(input: T) => T;
+export declare const makeStringEscaper: (regex: RegExp, replacement: string) => StringEscaper;
+export declare const coerceFilterChainOperands: (filterChain: (BinaryFilter | TernaryFilter)[], stringEscaper: StringEscaper) => (BinaryFilter | TernaryFilter)[];
+export declare const makeFilterSuffixes: (filterChain: (BinaryFilter | TernaryFilter)[], index: IndexDefinition) => {
+    left?: string;
+    right?: string;
+} | undefined;
+export declare const makeKeyForField: (definition: IndexDefinition, data: object, stringEscaper: StringEscaper) => string | null;
+export {};

package/dist/database/store/level.d.ts

@@ -1,29 +1,32 @@
 /**
-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 { Store } from './index';
+ 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 { StoreQueryOptions, StoreQueryResponse, PutOptions, DeleteOptions, SeedOptions, Store } from './index';
 import { LevelDB } from 'level';
 export declare class LevelStore implements Store {
     rootPath: any;
     db: LevelDB;
+    useMemory: boolean;
     constructor(rootPath: string, useMemory?: boolean);
-    query(queryStrings: string[], hydrator: any): Promise<any[]>;
-    seed(filepath: string, data: object): Promise<void>;
+    query(queryOptions: StoreQueryOptions): Promise<StoreQueryResponse>;
+    seed(filepath: string, data: object, options?: SeedOptions): Promise<void>;
     supportsSeeding(): boolean;
     supportsIndexing(): boolean;
+    delete(filepath: string, options: DeleteOptions): Promise<void>;
     print(): Promise<void>;
     open(): Promise<void>;
     clear(): Promise<void>;
     glob(pattern: string, callback: any): Promise<any[]>;
     get(filepath: string): Promise<any>;
-    put(filepath: string, data: object): Promise<void>;
+    close(): Promise<void>;
+    put(filepath: string, data: object, options?: PutOptions): Promise<void>;
 }

package/dist/index.d.ts

@@ -11,6 +11,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 export { FilesystemBridge, AuditFileSystemBridge, } from './database/bridge/filesystem';
+export { IsomorphicBridge } from './database/bridge/isomorphic';
 export { FilesystemStore, AuditFilesystemStore, } from './database/store/filesystem';
-export { MemoryStore } from './database/store/memory';
 export { LevelStore } from './database/store/level';
+export { coerceFilterChainOperands, DEFAULT_COLLECTION_SORT_KEY, DEFAULT_NUMERIC_LPAD, INDEX_KEY_FIELD_SEPARATOR, makeFilter, makeFilterChain, makeFilterSuffixes, makeKeyForField, makeStringEscaper, OP, } from './database/store';
+export type { BinaryFilter, FilterCondition, IndexDefinition, PadDefinition, StoreQueryOptions, StoreQueryResponse, PageInfo, PutOptions, DeleteOptions, SeedOptions, Store, TernaryFilter, } from './database/store';
+export declare type FilterOperand = string | number | boolean | string[] | number[];
+export { atob, btoa } from './util';