@tinacms/datalayer 0.0.0 → 0.1.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # tina-graphql
 
+## 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
+
+- b399c734c: Fixes support for collection.templates in graphql
+
+## 0.0.1
+
+### Patch Changes
+
+- 80732bd97: Create a @tinacms/datalayer package which houses the logic for data management for the GraphQL API. This simplifies the @tinacms/graphql package and allows for a clearer separation.
+
 ## 0.59.1
 
 ### Patch Changes

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

@@ -25,3 +25,9 @@ export declare class FilesystemBridge implements Bridge {
     putConfig(filepath: string, data: string): Promise<void>;
     put(filepath: string, data: 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/store/filesystem.d.ts

@@ -3,14 +3,14 @@ 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
+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 { Store } from '.';
+import { StoreQueryOptions, PutOptions, Store, StoreQueryResponse } from '.';
 export declare class FilesystemStore implements Store {
     rootPath: string;
     clear(): Promise<void>;
@@ -18,11 +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): Promise<void>;
+    put(filepath: string, data: object, options?: PutOptions): Promise<void>;
+    open(): Promise<void>;
+    close(): 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,93 @@ 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 interface Store {
     glob(pattern: string, hydrator?: (fullPath: string) => Promise<object>): Promise<string[]>;
     get<T extends object>(filepath: string): Promise<T>;
     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 +107,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,7 +117,24 @@ export interface Store {
      * user's repo.
      */
     supportsIndexing(): boolean;
-    put(filepath: string, data: object, options?: {
-        includeTemplate?: 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

@@ -10,14 +10,15 @@ 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';
+import type { StoreQueryOptions, StoreQueryResponse, PutOptions, 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;
     print(): Promise<void>;
@@ -25,5 +26,6 @@ export declare class LevelStore implements Store {
     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

@@ -1,19 +1,19 @@
 /**
-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.
-*/
-export { GithubBridge } from './database/bridge/github';
-export { GithubStore } from './database/store/github';
-export { FilesystemBridge } from './database/bridge/filesystem';
-export { FilesystemStore } from './database/store/filesystem';
-export { MemoryStore } from './database/store/memory';
+ 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.
+ */
+export { FilesystemBridge, AuditFileSystemBridge, } from './database/bridge/filesystem';
+export { FilesystemStore, AuditFilesystemStore, } from './database/store/filesystem';
 export { LevelStore } from './database/store/level';
-export type { GithubManagerInit } from './database/bridge/github';
+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, SeedOptions, Store, TernaryFilter, } from './database/store';
+export declare type FilterOperand = string | number | boolean | string[] | number[];
+export { atob, btoa } from './util';