@tinacms/datalayer 0.0.1 → 0.1.1

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # tina-graphql
 
+## 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
+
+- b399c734c: Fixes support for collection.templates in graphql
+
 ## 0.0.1
 
 ### Patch Changes

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

@@ -21,7 +21,14 @@ export declare class FilesystemBridge implements Bridge {
     constructor(rootPath: string);
     glob(pattern: 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>;
 }
+/**
+ * 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

@@ -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,11 +18,17 @@ 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>;
+    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[]>;
     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,7 +121,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,20 +10,23 @@ 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, 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

@@ -10,10 +10,10 @@ 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';
+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, DeleteOptions, SeedOptions, Store, TernaryFilter, } from './database/store';
+export declare type FilterOperand = string | number | boolean | string[] | number[];
+export { atob, btoa } from './util';