@tinacms/datalayer 0.0.2 → 0.1.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # 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

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,13 +18,15 @@ 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>;
+    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,5 +117,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

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

package/dist/index.js

@@ -55,10 +55,21 @@ var __toModule = (module2) => {
 __export(exports, {
   AuditFileSystemBridge: () => AuditFileSystemBridge,
   AuditFilesystemStore: () => AuditFilesystemStore,
+  DEFAULT_COLLECTION_SORT_KEY: () => DEFAULT_COLLECTION_SORT_KEY,
+  DEFAULT_NUMERIC_LPAD: () => DEFAULT_NUMERIC_LPAD,
   FilesystemBridge: () => FilesystemBridge,
   FilesystemStore: () => FilesystemStore,
+  INDEX_KEY_FIELD_SEPARATOR: () => INDEX_KEY_FIELD_SEPARATOR,
   LevelStore: () => LevelStore,
-  MemoryStore: () => MemoryStore
+  OP: () => OP,
+  atob: () => atob,
+  btoa: () => btoa,
+  coerceFilterChainOperands: () => coerceFilterChainOperands,
+  makeFilter: () => makeFilter,
+  makeFilterChain: () => makeFilterChain,
+  makeFilterSuffixes: () => makeFilterSuffixes,
+  makeKeyForField: () => makeKeyForField,
+  makeStringEscaper: () => makeStringEscaper
 });
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/database/bridge/filesystem.ts
@@ -140,6 +151,12 @@ function assertShape(value, yupSchema, errorMessage) {
     });
   }
 }
+var atob = (b64Encoded) => {
+  return Buffer.from(b64Encoded, "base64").toString();
+};
+var btoa = (string) => {
+  return Buffer.from(string).toString("base64");
+};
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/database/util.ts
 var stringifyFile = (content, format, keepTemplateKey) => {
@@ -205,7 +222,7 @@ var FilesystemStore = class {
   constructor({ rootPath }) {
     this.rootPath = rootPath || "";
   }
-  async query(queryStrings) {
+  async query(queryOptions) {
     throw new Error(`Unable to perform query for Filesystem store`);
   }
   async seed() {
@@ -237,8 +254,12 @@ var FilesystemStore = class {
       return items;
     }
   }
-  async put(filepath, data, keepTemplateKey) {
-    await import_fs_extra2.default.outputFileSync(import_path2.default.join(this.rootPath, filepath), stringifyFile(data, import_path2.default.extname(filepath), keepTemplateKey));
+  async put(filepath, data, options) {
+    await import_fs_extra2.default.outputFileSync(import_path2.default.join(this.rootPath, filepath), stringifyFile(data, import_path2.default.extname(filepath), options.keepTemplateKey));
+  }
+  async open() {
+  }
+  async close() {
   }
 };
 var AuditFilesystemStore = class extends FilesystemStore {
@@ -247,72 +268,342 @@ var AuditFilesystemStore = class extends FilesystemStore {
   }
 };
 
-// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/database/store/memory.ts
-var MemoryStore = class {
-  constructor(rootPath, object = {}) {
-    this.map = object;
-    this.rootPath = rootPath || "";
-    this.db = {
-      get: async (filepath) => {
-        return this.map[filepath];
-      },
-      put: async (filepath, content) => {
-        this.map[filepath] = content;
-        await this.print();
-      }
-    };
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/database/store/index.ts
+var import_jsonpath_plus = __toModule(require("jsonpath-plus"));
+var DEFAULT_COLLECTION_SORT_KEY = "__filepath__";
+var INDEX_KEY_FIELD_SEPARATOR = "#";
+var DEFAULT_NUMERIC_LPAD = 4;
+var OP;
+(function(OP2) {
+  OP2["EQ"] = "eq";
+  OP2["GT"] = "gt";
+  OP2["LT"] = "lt";
+  OP2["GTE"] = "gte";
+  OP2["LTE"] = "lte";
+  OP2["STARTS_WITH"] = "startsWith";
+  OP2["IN"] = "in";
+})(OP || (OP = {}));
+var inferOperatorFromFilter = (filterOperator) => {
+  switch (filterOperator) {
+    case "after":
+      return OP.GT;
+    case "before":
+      return OP.LT;
+    case "eq":
+      return OP.EQ;
+    case "startsWith":
+      return OP.STARTS_WITH;
+    case "lt":
+      return OP.LT;
+    case "lte":
+      return OP.LTE;
+    case "gt":
+      return OP.GT;
+    case "gte":
+      return OP.GTE;
+    case "in":
+      return OP.IN;
+    default:
+      throw new Error(`unsupported filter condition: '${filterOperator}'`);
   }
-  async query(queryStrings, hydrator) {
-    const resultSets = await sequential(queryStrings, async (queryString) => {
-      const res = await this.get(queryString);
-      return res || [];
-    });
-    let items = [];
-    if (resultSets.length > 0) {
-      items = resultSets.reduce((p, c) => p.filter((e) => c.includes(e)));
+};
+var getFilterOperator = (expression, operand) => {
+  return (expression[operand] || expression[operand] === 0) && operand;
+};
+var makeFilterChain = ({
+  conditions
+}) => {
+  const filterChain = [];
+  if (!conditions) {
+    return filterChain;
+  }
+  for (const condition of conditions) {
+    const { filterPath, filterExpression } = condition;
+    const _a = filterExpression, { _type } = _a, keys = __objRest(_a, ["_type"]);
+    const [key1, key2, ...extraKeys] = Object.keys(keys);
+    if (extraKeys.length) {
+      throw new Error(`Unexpected keys: [${extraKeys.join(",")}] in filter expression`);
+    }
+    if (key1 && !key2) {
+      filterChain.push({
+        pathExpression: filterPath,
+        rightOperand: filterExpression[key1],
+        operator: inferOperatorFromFilter(key1),
+        type: _type,
+        pad: _type === "number" ? { fillString: "0", maxLength: DEFAULT_NUMERIC_LPAD } : void 0
+      });
+    } else if (key1 && key2) {
+      const leftFilterOperator = getFilterOperator(filterExpression, "gt") || getFilterOperator(filterExpression, "gte") || getFilterOperator(filterExpression, "after") || void 0;
+      const rightFilterOperator = getFilterOperator(filterExpression, "lt") || getFilterOperator(filterExpression, "lte") || getFilterOperator(filterExpression, "before") || void 0;
+      let leftOperand;
+      let rightOperand;
+      if (rightFilterOperator && leftFilterOperator) {
+        if (key1 === leftFilterOperator) {
+          leftOperand = filterExpression[key1];
+          rightOperand = filterExpression[key2];
+        } else {
+          rightOperand = filterExpression[key1];
+          leftOperand = filterExpression[key2];
+        }
+        filterChain.push({
+          pathExpression: filterPath,
+          rightOperand,
+          leftOperand,
+          leftOperator: inferOperatorFromFilter(leftFilterOperator),
+          rightOperator: inferOperatorFromFilter(rightFilterOperator),
+          type: _type,
+          pad: _type === "number" ? { fillString: "0", maxLength: DEFAULT_NUMERIC_LPAD } : void 0
+        });
+      } else {
+        throw new Error(`Filter on field '${filterPath}' has invalid combination of conditions: '${key1}, ${key2}'`);
+      }
     }
-    return sequential(items, async (documentString) => {
-      return hydrator(documentString);
-    });
-  }
-  async seed(filepath, data) {
-    await this.put(filepath, data);
-  }
-  supportsSeeding() {
-    return true;
-  }
-  supportsIndexing() {
-    return true;
-  }
-  async print() {
-  }
-  async clear() {
-    this.map = {};
   }
-  async glob(pattern, callback) {
-    const strings = Object.keys(this.map).filter((key) => {
-      if (key.startsWith(pattern)) {
-        return true;
+  return filterChain;
+};
+var makeFilter = ({
+  filterChain
+}) => {
+  return (values) => {
+    for (const filter of filterChain) {
+      const dataType = filter.type;
+      const resolvedValues = (0, import_jsonpath_plus.JSONPath)({
+        path: filter.pathExpression,
+        json: values
+      });
+      if (!resolvedValues || !resolvedValues.length) {
+        return false;
+      }
+      let operands;
+      if (dataType === "string" || dataType === "reference") {
+        operands = resolvedValues;
+      } else if (dataType === "number" || dataType === "datetime") {
+        operands = resolvedValues.map((resolvedValue) => Number(resolvedValue));
+      } else if (dataType === "boolean") {
+        operands = resolvedValues.map((resolvedValue) => typeof resolvedValue === "boolean" && resolvedValue || resolvedValue === "true" || resolvedValue === "1");
       } else {
+        throw new Error(`Unexpected datatype ${dataType}`);
+      }
+      const { operator } = filter;
+      let matches = false;
+      if (operator) {
+        switch (operator) {
+          case OP.EQ:
+            if (operands.findIndex((operand) => operand === filter.rightOperand) >= 0) {
+              matches = true;
+            }
+            break;
+          case OP.GT:
+            for (const operand of operands) {
+              if (operand > filter.rightOperand) {
+                matches = true;
+                break;
+              }
+            }
+            break;
+          case OP.LT:
+            for (const operand of operands) {
+              if (operand < filter.rightOperand) {
+                matches = true;
+                break;
+              }
+            }
+            break;
+          case OP.GTE:
+            for (const operand of operands) {
+              if (operand >= filter.rightOperand) {
+                matches = true;
+                break;
+              }
+            }
+            break;
+          case OP.LTE:
+            for (const operand of operands) {
+              if (operand <= filter.rightOperand) {
+                matches = true;
+                break;
+              }
+            }
+            break;
+          case OP.IN:
+            for (const operand of operands) {
+              if (filter.rightOperand.indexOf(operand) >= 0) {
+                matches = true;
+                break;
+              }
+            }
+            break;
+          case OP.STARTS_WITH:
+            for (const operand of operands) {
+              if (operand.startsWith(filter.rightOperand)) {
+                matches = true;
+                break;
+              }
+            }
+            break;
+          default:
+            throw new Error(`unexpected operator ${operator}`);
+        }
+      } else {
+        const { rightOperator, leftOperator, rightOperand, leftOperand } = filter;
+        for (const operand of operands) {
+          let rightMatches = false;
+          let leftMatches = false;
+          if (rightOperator === OP.LTE && operand <= rightOperand) {
+            rightMatches = true;
+          } else if (rightOperator === OP.LT && operand < rightOperand) {
+            rightMatches = true;
+          }
+          if (leftOperator === OP.GTE && operand >= leftOperand) {
+            leftMatches = true;
+          } else if (leftOperator === OP.GT && operand > leftOperand) {
+            leftMatches = true;
+          }
+          if (rightMatches && leftMatches) {
+            matches = true;
+            break;
+          }
+        }
+      }
+      if (!matches) {
         return false;
       }
-    });
-    if (callback) {
-      return sequential(strings, async (item) => {
-        return callback(item);
-      });
+    }
+    return true;
+  };
+};
+var makeStringEscaper = (regex, replacement) => {
+  return (input) => {
+    if (Array.isArray(input)) {
+      return input.map((val) => val.replace(regex, replacement));
     } else {
-      return strings;
+      return input.replace(regex, replacement);
+    }
+  };
+};
+var applyPadding = (input, pad) => {
+  if (pad) {
+    if (Array.isArray(input)) {
+      return input.map((val) => String(val).padStart(pad.maxLength, pad.fillString));
+    } else {
+      return String(input).padStart(pad.maxLength, pad.fillString);
     }
   }
-  async get(filepath) {
-    const content = await this.db.get(filepath);
-    return content;
+  return input;
+};
+var coerceFilterChainOperands = (filterChain, stringEscaper) => {
+  const result = [];
+  if (filterChain.length) {
+    for (const filter of filterChain) {
+      const dataType = filter.type;
+      if (dataType === "datetime") {
+        if (filter.leftOperand !== void 0) {
+          result.push(__spreadProps(__spreadValues({}, filter), {
+            rightOperand: new Date(filter.rightOperand).getTime(),
+            leftOperand: new Date(filter.leftOperand).getTime()
+          }));
+        } else {
+          if (Array.isArray(filter.rightOperand)) {
+            result.push(__spreadProps(__spreadValues({}, filter), {
+              rightOperand: filter.rightOperand.map((operand) => new Date(operand).getTime())
+            }));
+          } else {
+            result.push(__spreadProps(__spreadValues({}, filter), {
+              rightOperand: new Date(filter.rightOperand).getTime()
+            }));
+          }
+        }
+      } else if (dataType === "string") {
+        if (filter.leftOperand !== void 0) {
+          result.push(__spreadProps(__spreadValues({}, filter), {
+            rightOperand: applyPadding(stringEscaper(filter.rightOperand), filter.pad),
+            leftOperand: applyPadding(stringEscaper(filter.leftOperand), filter.pad)
+          }));
+        } else {
+          result.push(__spreadProps(__spreadValues({}, filter), {
+            rightOperand: applyPadding(stringEscaper(filter.rightOperand), filter.pad)
+          }));
+        }
+      } else {
+        result.push(__spreadValues({}, filter));
+      }
+    }
   }
-  async put(filepath, data) {
-    await this.db.put(filepath, data);
+  return result;
+};
+var makeFilterSuffixes = (filterChain, index) => {
+  if (filterChain && filterChain.length) {
+    const indexFields = index.fields.map((field) => field.name);
+    const orderedFilterChain = [];
+    for (const filter of filterChain) {
+      const idx = indexFields.indexOf(filter.pathExpression);
+      if (idx === -1) {
+        return;
+      }
+      if (filter.operator && filter.operator === OP.IN) {
+        return;
+      }
+      orderedFilterChain[idx] = filter;
+    }
+    const baseFragments = [];
+    let rightSuffix;
+    let leftSuffix;
+    let ternaryFilter = false;
+    if (orderedFilterChain[filterChain.length - 1] && !orderedFilterChain[filterChain.length - 1].operator) {
+      ternaryFilter = true;
+    }
+    for (let i = 0; i < orderedFilterChain.length; i++) {
+      const filter = orderedFilterChain[i];
+      if (!filter) {
+        return;
+      }
+      if (Number(i) < indexFields.length - 1) {
+        if (!filter.operator) {
+          return;
+        }
+        const binaryFilter = filter;
+        if (binaryFilter.operator !== OP.EQ) {
+          return;
+        }
+        baseFragments.push(applyPadding(orderedFilterChain[i].rightOperand, orderedFilterChain[i].pad));
+      } else {
+        if (ternaryFilter) {
+          leftSuffix = applyPadding(orderedFilterChain[i].leftOperand, orderedFilterChain[i].pad);
+          rightSuffix = applyPadding(orderedFilterChain[i].rightOperand, orderedFilterChain[i].pad);
+        } else {
+          const op = orderedFilterChain[i].operator;
+          const operand = applyPadding(orderedFilterChain[i].rightOperand, orderedFilterChain[i].pad);
+          if (op === OP.LT || op === OP.LTE) {
+            rightSuffix = operand;
+          } else if (op === OP.GT || op === OP.GTE) {
+            leftSuffix = operand;
+          } else {
+            rightSuffix = operand;
+            leftSuffix = operand;
+          }
+        }
+      }
+    }
+    return {
+      left: leftSuffix && [...baseFragments, leftSuffix].join(INDEX_KEY_FIELD_SEPARATOR) || void 0,
+      right: rightSuffix && [...baseFragments, rightSuffix].join(INDEX_KEY_FIELD_SEPARATOR) || void 0
+    };
+  } else {
+    return {};
   }
 };
+var makeKeyForField = (definition, data, stringEscaper) => {
+  const valueParts = [];
+  for (const field of definition.fields) {
+    if (field.name in data) {
+      const resolvedValue = String(field.type === "datetime" ? new Date(data[field.name]).getTime() : field.type === "string" ? stringEscaper(data[field.name]) : data[field.name]);
+      valueParts.push(applyPadding(resolvedValue, field.pad));
+    } else {
+      return null;
+    }
+  }
+  return valueParts.join(INDEX_KEY_FIELD_SEPARATOR);
+};
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/database/store/level.ts
 var import_path3 = __toModule(require("path"));
@@ -320,47 +611,89 @@ var import_level = __toModule(require("level"));
 var import_levelup = __toModule(require("levelup"));
 var import_memdown = __toModule(require("memdown"));
 var import_encoding_down = __toModule(require("encoding-down"));
+var defaultPrefix = "_ROOT_";
+var escapeStr = makeStringEscaper(new RegExp(INDEX_KEY_FIELD_SEPARATOR, "gm"), encodeURIComponent(INDEX_KEY_FIELD_SEPARATOR));
 var LevelStore = class {
   constructor(rootPath, useMemory = false) {
     this.rootPath = rootPath || "";
+    this.useMemory = useMemory;
     if (useMemory) {
-      const db = (0, import_levelup.default)((0, import_encoding_down.default)((0, import_memdown.default)(), { valueEncoding: "json" }));
-      this.db = db;
+      this.db = (0, import_levelup.default)((0, import_encoding_down.default)((0, import_memdown.default)(), { valueEncoding: "json" }));
     } else {
-      const db = (0, import_level.default)(import_path3.default.join(rootPath, ".tina/__generated__/db"), {
+      this.db = (0, import_level.default)(import_path3.default.join(rootPath, ".tina/__generated__/db"), {
         valueEncoding: "json"
       });
-      this.db = db;
     }
   }
-  async query(queryStrings, hydrator) {
-    const resultSets = await sequential(queryStrings, async (queryString) => {
-      let strings = [];
-      const p = new Promise((resolve, reject) => {
-        this.db.createReadStream({
-          gte: queryString,
-          lte: queryString + "\xFF"
-        }).on("data", (data) => {
-          strings = [...strings, ...data.value];
-        }).on("error", (message) => {
-          reject(message);
-        }).on("end", function() {
-          resolve();
-        });
-      });
-      await p;
-      return strings || [];
-    });
-    let items = [];
-    if (resultSets.length > 0) {
-      items = resultSets.reduce((p, c) => p.filter((e) => c.includes(e)));
+  async query(queryOptions) {
+    var _b;
+    const _a = queryOptions, {
+      filterChain: rawFilterChain,
+      sort = DEFAULT_COLLECTION_SORT_KEY,
+      collection,
+      indexDefinitions,
+      limit = 10
+    } = _a, query = __objRest(_a, [
+      "filterChain",
+      "sort",
+      "collection",
+      "indexDefinitions",
+      "limit"
+    ]);
+    const filterChain = coerceFilterChainOperands(rawFilterChain, escapeStr);
+    const indexDefinition = sort && (indexDefinitions == null ? void 0 : indexDefinitions[sort]);
+    const filterSuffixes = indexDefinition && makeFilterSuffixes(filterChain, indexDefinition);
+    const indexPrefix = indexDefinition ? `${collection}${INDEX_KEY_FIELD_SEPARATOR}${sort}` : `${defaultPrefix}${INDEX_KEY_FIELD_SEPARATOR}`;
+    if (!query.gt && !query.gte) {
+      query.gte = (filterSuffixes == null ? void 0 : filterSuffixes.left) ? `${indexPrefix}${INDEX_KEY_FIELD_SEPARATOR}${filterSuffixes.left}` : indexPrefix;
     }
-    return sequential(items, async (documentString) => {
-      return hydrator(documentString);
-    });
+    if (!query.lt && !query.lte) {
+      query.lte = (filterSuffixes == null ? void 0 : filterSuffixes.right) ? `${indexPrefix}${INDEX_KEY_FIELD_SEPARATOR}${filterSuffixes.right}\xFF` : `${indexPrefix}\xFF`;
+    }
+    let edges = [];
+    let startKey = "";
+    let endKey = "";
+    let hasPreviousPage = false;
+    let hasNextPage = false;
+    const fieldsPattern = ((_b = indexDefinition == null ? void 0 : indexDefinition.fields) == null ? void 0 : _b.length) ? `${indexDefinition.fields.map((p) => `${INDEX_KEY_FIELD_SEPARATOR}(?<${p.name}>.+)`).join("")}${INDEX_KEY_FIELD_SEPARATOR}` : INDEX_KEY_FIELD_SEPARATOR;
+    const valuesRegex = indexDefinition ? new RegExp(`^${indexPrefix}${fieldsPattern}(?<_filepath_>.+)`) : new RegExp(`^${indexPrefix}(?<_filepath_>.+)`);
+    const itemFilter = makeFilter({ filterChain });
+    for await (const [key, value] of this.db.iterator(query)) {
+      const matcher = valuesRegex.exec(key);
+      if (!matcher || indexDefinition && matcher.length !== indexDefinition.fields.length + 2) {
+        continue;
+      }
+      const filepath = matcher.groups["_filepath_"];
+      if (!itemFilter(filterSuffixes ? matcher.groups : indexDefinition ? await this.db.get(`${defaultPrefix}${INDEX_KEY_FIELD_SEPARATOR}${filepath}`) : value)) {
+        continue;
+      }
+      if (limit !== -1 && edges.length >= limit) {
+        if (query.reverse) {
+          hasPreviousPage = true;
+        } else {
+          hasNextPage = true;
+        }
+        break;
+      }
+      startKey = startKey || key || "";
+      endKey = key || "";
+      edges = [...edges, { cursor: key, path: filepath }];
+    }
+    return {
+      edges,
+      pageInfo: {
+        hasPreviousPage,
+        hasNextPage,
+        startCursor: startKey,
+        endCursor: endKey
+      }
+    };
   }
-  async seed(filepath, data) {
-    await this.put(filepath, data);
+  async seed(filepath, data, options) {
+    await this.put(filepath, data, __spreadValues({
+      keepTemplateKey: false,
+      seed: true
+    }, options));
   }
   supportsSeeding() {
     return true;
@@ -389,10 +722,10 @@ var LevelStore = class {
     const strings = [];
     const p = new Promise((resolve, reject) => {
       this.db.createKeyStream({
-        gte: pattern,
-        lte: pattern + "\xFF"
+        gte: `${defaultPrefix}${INDEX_KEY_FIELD_SEPARATOR}${pattern}`,
+        lte: `${defaultPrefix}${INDEX_KEY_FIELD_SEPARATOR}${pattern}\xFF`
       }).on("data", (data) => {
-        strings.push(data);
+        strings.push(data.split(`${defaultPrefix}${INDEX_KEY_FIELD_SEPARATOR}`)[1]);
       }).on("error", (message) => {
         reject(message);
       }).on("end", function() {
@@ -410,22 +743,64 @@ var LevelStore = class {
   }
   async get(filepath) {
     try {
-      const content = await this.db.get(filepath);
-      return content;
+      return await this.db.get(`${defaultPrefix}${INDEX_KEY_FIELD_SEPARATOR}${filepath}`);
     } catch (e) {
       return void 0;
     }
   }
-  async put(filepath, data) {
-    await this.db.put(filepath, data);
+  async close() {
+    await this.db.close();
+  }
+  async put(filepath, data, options) {
+    let existingData;
+    try {
+      existingData = options && !options.seed ? await this.db.get(`${defaultPrefix}${INDEX_KEY_FIELD_SEPARATOR}${filepath}`) : null;
+    } catch (err) {
+      if (!err.notFound) {
+        throw err;
+      }
+    }
+    await this.db.put(`${defaultPrefix}${INDEX_KEY_FIELD_SEPARATOR}${filepath}`, data);
+    if (options == null ? void 0 : options.indexDefinitions) {
+      for (const [sort, definition] of Object.entries(options.indexDefinitions)) {
+        const indexedValue = makeKeyForField(definition, data, escapeStr);
+        const existingIndexedValue = existingData ? makeKeyForField(definition, existingData, escapeStr) : null;
+        let indexKey;
+        let existingIndexKey = null;
+        if (sort === DEFAULT_COLLECTION_SORT_KEY) {
+          indexKey = `${options.collection}${INDEX_KEY_FIELD_SEPARATOR}${sort}${INDEX_KEY_FIELD_SEPARATOR}${filepath}`;
+          existingIndexKey = indexKey;
+        } else {
+          indexKey = indexedValue ? `${options.collection}${INDEX_KEY_FIELD_SEPARATOR}${sort}${INDEX_KEY_FIELD_SEPARATOR}${indexedValue}${INDEX_KEY_FIELD_SEPARATOR}${filepath}` : null;
+          existingIndexKey = existingIndexedValue ? `${options.collection}${INDEX_KEY_FIELD_SEPARATOR}${sort}${INDEX_KEY_FIELD_SEPARATOR}${existingIndexedValue}${INDEX_KEY_FIELD_SEPARATOR}${filepath}` : null;
+        }
+        if (indexKey) {
+          if (existingIndexKey && indexKey != existingIndexKey) {
+            await this.db.del(existingIndexKey);
+          }
+          await this.db.put(indexKey, "");
+        }
+      }
+    }
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuditFileSystemBridge,
   AuditFilesystemStore,
+  DEFAULT_COLLECTION_SORT_KEY,
+  DEFAULT_NUMERIC_LPAD,
   FilesystemBridge,
   FilesystemStore,
+  INDEX_KEY_FIELD_SEPARATOR,
   LevelStore,
-  MemoryStore
+  OP,
+  atob,
+  btoa,
+  coerceFilterChainOperands,
+  makeFilter,
+  makeFilterChain,
+  makeFilterSuffixes,
+  makeKeyForField,
+  makeStringEscaper
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinacms/datalayer",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "files": [
@@ -32,7 +32,9 @@
     "graphql": "^15.3.0",
     "gray-matter": "^4.0.2",
     "js-yaml": "^3.14.0",
+    "jsonpath-plus": "^6.0.1",
     "level": "^7.0.1",
+    "leveldown": "^6.1.0",
     "levelup": "^5.1.1",
     "lodash": "^4.17.20",
     "memdown": "^6.1.1",
@@ -48,9 +50,9 @@
     "directory": "packages/@tinacms/datalayer"
   },
   "devDependencies": {
-    "@tinacms/scripts": "0.50.5",
+    "@tinacms/scripts": "0.50.7",
     "@types/fs-extra": "^9.0.2",
-    "@types/jest": "^26.0.4",
+    "@types/jest": "^27.4.1",
     "@types/js-yaml": "^3.12.5",
     "@types/level": "^6.0.0",
     "@types/lodash": "^4.14.161",

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

@@ -1,33 +0,0 @@
-/**
-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';
-/**
- * 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 MemoryStore implements Store {
-    rootPath: any;
-    db: any;
-    private map;
-    constructor(rootPath: string, object?: object);
-    query(queryStrings: string[], hydrator: any): Promise<any[]>;
-    seed(filepath: string, data: object): Promise<void>;
-    supportsSeeding(): boolean;
-    supportsIndexing(): boolean;
-    print(): Promise<void>;
-    clear(): Promise<void>;
-    glob(pattern: string, callback: any): Promise<any[]>;
-    get(filepath: string): Promise<any>;
-    put(filepath: string, data: object): Promise<void>;
-}