@tinacms/datalayer 0.0.1 → 0.1.1

package/dist/index.js

@@ -51,112 +51,80 @@ var __toModule = (module2) => {
   return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
 };
 
-// pnp:/Users/jeffsee/code/tinacms/packages/@tinacms/datalayer/src/index.ts
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/index.ts
 __export(exports, {
+  AuditFileSystemBridge: () => AuditFileSystemBridge,
+  AuditFilesystemStore: () => AuditFilesystemStore,
+  DEFAULT_COLLECTION_SORT_KEY: () => DEFAULT_COLLECTION_SORT_KEY,
+  DEFAULT_NUMERIC_LPAD: () => DEFAULT_NUMERIC_LPAD,
   FilesystemBridge: () => FilesystemBridge,
   FilesystemStore: () => FilesystemStore,
-  GithubBridge: () => GithubBridge,
-  GithubStore: () => GithubStore,
+  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:/Users/jeffsee/code/tinacms/packages/@tinacms/datalayer/src/database/bridge/github.ts
-var import_lodash = __toModule(require("lodash"));
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/database/bridge/filesystem.ts
+var import_fs_extra = __toModule(require("fs-extra"));
+var import_fast_glob = __toModule(require("fast-glob"));
 var import_path = __toModule(require("path"));
-var import_rest = __toModule(require("@octokit/rest"));
-var import_graphql = __toModule(require("graphql"));
-var GithubBridge = class {
-  constructor({ rootPath, accessToken, owner, repo, ref }) {
-    this.rootPath = rootPath;
-    this.repoConfig = {
-      owner,
-      repo,
-      ref
-    };
-    this.appOctoKit = new import_rest.Octokit({
-      auth: accessToken
-    });
+var import_normalize_path = __toModule(require("normalize-path"));
+var FilesystemBridge = class {
+  constructor(rootPath) {
+    this.rootPath = rootPath || "";
   }
-  async readDir(filepath) {
-    const fullPath = import_path.default.join(this.rootPath, filepath);
-    const repos = await this.appOctoKit.repos.getContent(__spreadProps(__spreadValues({}, this.repoConfig), {
-      path: fullPath
-    })).then(async (response) => {
-      if (Array.isArray(response.data)) {
-        return await Promise.all(await response.data.map(async (d) => {
-          if (d.type === "dir") {
-            const nestedItems = await this.readDir(d.path);
-            if (Array.isArray(nestedItems)) {
-              return nestedItems.map((nestedItem) => {
-                return import_path.default.join(d.path, nestedItem);
-              });
-            } else {
-              throw new Error(`Expected items to be an array of strings for readDir at ${d.path}`);
-            }
-          }
-          return d.path;
-        }));
-      }
-      throw new Error(`Expected to return an array from Github directory ${import_path.default}`);
+  async glob(pattern) {
+    const basePath = import_path.default.join(this.rootPath, ...pattern.split("/"));
+    const items = await (0, import_fast_glob.default)(import_path.default.join(basePath, "**", "/*").replace(/\\/g, "/"), {
+      dot: true
+    });
+    const posixRootPath = (0, import_normalize_path.default)(this.rootPath);
+    return items.map((item) => {
+      return item.replace(posixRootPath, "").replace(/^\/|\/$/g, "");
     });
-    return import_lodash.default.flatten(repos);
   }
   supportsBuilding() {
-    return false;
+    return true;
   }
-  async glob(pattern) {
-    const results = await this.readDir(pattern);
-    return results.map((item) => item.replace(this.rootPath, "").replace(/^\/|\/$/g, ""));
+  async delete(filepath) {
+    await import_fs_extra.default.remove(import_path.default.join(this.rootPath, filepath));
   }
   async get(filepath) {
-    const realpath = import_path.default.join(this.rootPath, filepath);
-    return this.appOctoKit.repos.getContent(__spreadProps(__spreadValues({}, this.repoConfig), {
-      path: realpath
-    })).then((response) => {
-      return Buffer.from(response.data.content, "base64").toString();
-    }).catch((e) => {
-      if (e.status === 401) {
-        throw new import_graphql.GraphQLError(`Unauthorized request to Github Repository: '${this.repoConfig.owner}/${this.repoConfig.repo}', please ensure your access token is valid.`, null, null, null, null, e, { status: e.status });
-      }
-      throw new import_graphql.GraphQLError(`Unable to find record '${filepath}' in Github Repository: '${this.repoConfig.owner}/${this.repoConfig.repo}', Ref: '${this.repoConfig.ref}'`, null, null, null, null, e, { status: e.status });
-    });
+    return import_fs_extra.default.readFileSync(import_path.default.join(this.rootPath, filepath)).toString();
   }
   async putConfig(filepath, data) {
-    throw new Error(`Config files cannot be changed by the Github bridge`);
+    await this.put(filepath, data);
   }
   async put(filepath, data) {
-    const realpath = import_path.default.join(this.rootPath, filepath);
-    let fileSha = void 0;
-    try {
-      const fileContent = await this.appOctoKit.repos.getContent(__spreadProps(__spreadValues({}, this.repoConfig), {
-        path: realpath
-      }));
-      fileSha = fileContent.data.sha;
-    } catch (e) {
-      console.log("No file exists, creating new one");
-    }
-    await this.appOctoKit.repos.createOrUpdateFileContents(__spreadProps(__spreadValues({}, this.repoConfig), {
-      branch: this.repoConfig.ref,
-      path: realpath,
-      message: "Update from GraphQL client",
-      content: new Buffer(data).toString("base64"),
-      sha: fileSha
-    }));
+    await import_fs_extra.default.outputFileSync(import_path.default.join(this.rootPath, filepath), data);
+  }
+};
+var AuditFileSystemBridge = class extends FilesystemBridge {
+  async put(_filepath, _data) {
+    return;
   }
 };
 
-// pnp:/Users/jeffsee/code/tinacms/packages/@tinacms/datalayer/src/database/store/github.ts
-var import_lodash2 = __toModule(require("lodash"));
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/database/store/filesystem.ts
+var import_fs_extra2 = __toModule(require("fs-extra"));
+var import_fast_glob2 = __toModule(require("fast-glob"));
 var import_path2 = __toModule(require("path"));
-var import_rest2 = __toModule(require("@octokit/rest"));
+var import_normalize_path2 = __toModule(require("normalize-path"));
 
-// pnp:/Users/jeffsee/code/tinacms/packages/@tinacms/datalayer/src/database/util.ts
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/database/util.ts
 var import_gray_matter = __toModule(require("gray-matter"));
 
-// pnp:/Users/jeffsee/code/tinacms/packages/@tinacms/datalayer/src/util.ts
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/util.ts
 var yup = __toModule(require("yup"));
-var import_graphql2 = __toModule(require("graphql"));
+var import_graphql = __toModule(require("graphql"));
 var sequential = async (items, callback) => {
   const accum = [];
   if (!items) {
@@ -181,13 +149,19 @@ function assertShape(value, yupSchema, errorMessage) {
     shape.validateSync(value);
   } catch (e) {
     const message = errorMessage || `Failed to assertShape - ${e.message}`;
-    throw new import_graphql2.GraphQLError(message, null, null, null, null, null, {
+    throw new import_graphql.GraphQLError(message, null, null, null, null, null, {
       stack: e.stack
     });
   }
 }
+var atob = (b64Encoded) => {
+  return Buffer.from(b64Encoded, "base64").toString();
+};
+var btoa = (string) => {
+  return Buffer.from(string).toString("base64");
+};
 
-// pnp:/Users/jeffsee/code/tinacms/packages/@tinacms/datalayer/src/database/util.ts
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/database/util.ts
 var stringifyFile = (content, format, keepTemplateKey) => {
   switch (format) {
     case ".markdown":
@@ -242,144 +216,7 @@ var parseFile = (content, format, yupSchema) => {
   }
 };
 
-// pnp:/Users/jeffsee/code/tinacms/packages/@tinacms/datalayer/src/database/store/github.ts
-var import_graphql3 = __toModule(require("graphql"));
-var GithubStore = class {
-  async clear() {
-  }
-  async print() {
-  }
-  constructor({ rootPath, accessToken, owner, repo, ref }) {
-    this.rootPath = rootPath;
-    this.repoConfig = {
-      owner,
-      repo,
-      ref
-    };
-    this.appOctoKit = new import_rest2.Octokit({
-      auth: accessToken
-    });
-  }
-  async query(queryStrings) {
-    throw new Error(`Unable to perform query for GithubStore`);
-  }
-  supportsSeeding() {
-    return false;
-  }
-  async seed() {
-    throw new Error(`Seeding data is not possible for Github data store`);
-  }
-  async readDir(filepath) {
-    const fullPath = import_path2.default.join(this.rootPath, filepath);
-    const repos = await this.appOctoKit.repos.getContent(__spreadProps(__spreadValues({}, this.repoConfig), {
-      path: fullPath
-    })).then(async (response) => {
-      if (Array.isArray(response.data)) {
-        return await Promise.all(await response.data.map(async (d) => {
-          if (d.type === "dir") {
-            const nestedItems = await this.readDir(d.path);
-            if (Array.isArray(nestedItems)) {
-              return nestedItems.map((nestedItem) => {
-                return import_path2.default.join(d.path, nestedItem);
-              });
-            } else {
-              throw new Error(`Expected items to be an array of strings for readDir at ${d.path}`);
-            }
-          }
-          return d.path;
-        }));
-      }
-      throw new Error(`Expected to return an array from Github directory ${import_path2.default}`);
-    });
-    return import_lodash2.default.flatten(repos);
-  }
-  async glob(pattern, callback) {
-    const results = await this.readDir(pattern);
-    const items = results.map((item) => item.replace(this.rootPath, "").replace(/^\/|\/$/g, ""));
-    if (callback) {
-      return sequential(items, async (item) => {
-        return callback(item);
-      });
-    } else {
-      return items;
-    }
-  }
-  async get(filepath) {
-    const realpath = import_path2.default.join(this.rootPath, filepath);
-    return this.appOctoKit.repos.getContent(__spreadProps(__spreadValues({}, this.repoConfig), {
-      path: realpath
-    })).then((response) => {
-      const responseString = Buffer.from(response.data.content, "base64").toString();
-      return parseFile(responseString, import_path2.default.extname(filepath), (yup2) => yup2.object());
-    }).catch((e) => {
-      if (e.status === 401) {
-        throw new import_graphql3.GraphQLError(`Unauthorized request to Github Repository: '${this.repoConfig.owner}/${this.repoConfig.repo}', please ensure your access token is valid.`, null, null, null, null, e, { status: e.status });
-      }
-      throw new import_graphql3.GraphQLError(`Unable to find record '${filepath}' in Github Repository: '${this.repoConfig.owner}/${this.repoConfig.repo}', Ref: '${this.repoConfig.ref}'`, null, null, null, null, e, { status: e.status });
-    });
-  }
-  supportsIndexing() {
-    return false;
-  }
-  async put(filepath, data) {
-    const realpath = import_path2.default.join(this.rootPath, filepath);
-    let fileSha = void 0;
-    try {
-      const fileContent = await this.appOctoKit.repos.getContent(__spreadProps(__spreadValues({}, this.repoConfig), {
-        path: realpath
-      }));
-      fileSha = fileContent.data.sha;
-    } catch (e) {
-      console.log("No file exists, creating new one");
-    }
-    await this.appOctoKit.repos.createOrUpdateFileContents(__spreadProps(__spreadValues({}, this.repoConfig), {
-      branch: this.repoConfig.ref,
-      path: realpath,
-      message: "Update from GraphQL client",
-      content: new Buffer(stringifyFile(data, import_path2.default.extname(filepath), false)).toString("base64"),
-      sha: fileSha
-    }));
-  }
-};
-
-// pnp:/Users/jeffsee/code/tinacms/packages/@tinacms/datalayer/src/database/bridge/filesystem.ts
-var import_fs_extra = __toModule(require("fs-extra"));
-var import_fast_glob = __toModule(require("fast-glob"));
-var import_path3 = __toModule(require("path"));
-var import_normalize_path = __toModule(require("normalize-path"));
-var FilesystemBridge = class {
-  constructor(rootPath) {
-    this.rootPath = rootPath || "";
-  }
-  async glob(pattern) {
-    const basePath = import_path3.default.join(this.rootPath, ...pattern.split("/"));
-    const items = await (0, import_fast_glob.default)(import_path3.default.join(basePath, "**", "/*").replace(/\\/g, "/"), {
-      dot: true
-    });
-    const posixRootPath = (0, import_normalize_path.default)(this.rootPath);
-    return items.map((item) => {
-      return item.replace(posixRootPath, "").replace(/^\/|\/$/g, "");
-    });
-  }
-  supportsBuilding() {
-    return true;
-  }
-  async get(filepath) {
-    return import_fs_extra.default.readFileSync(import_path3.default.join(this.rootPath, filepath)).toString();
-  }
-  async putConfig(filepath, data) {
-    await this.put(filepath, data);
-  }
-  async put(filepath, data) {
-    await import_fs_extra.default.outputFileSync(import_path3.default.join(this.rootPath, filepath), data);
-  }
-};
-
-// pnp:/Users/jeffsee/code/tinacms/packages/@tinacms/datalayer/src/database/store/filesystem.ts
-var import_fs_extra2 = __toModule(require("fs-extra"));
-var import_fast_glob2 = __toModule(require("fast-glob"));
-var import_path4 = __toModule(require("path"));
-var import_normalize_path2 = __toModule(require("normalize-path"));
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/database/store/filesystem.ts
 var FilesystemStore = class {
   async clear() {
   }
@@ -388,14 +225,14 @@ 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() {
     throw new Error(`Seeding data is not possible for Filesystem store`);
   }
   async get(filepath) {
-    return parseFile(await import_fs_extra2.default.readFileSync(import_path4.default.join(this.rootPath, filepath)).toString(), import_path4.default.extname(filepath), (yup2) => yup2.object());
+    return parseFile(await import_fs_extra2.default.readFileSync(import_path2.default.join(this.rootPath, filepath)).toString(), import_path2.default.extname(filepath), (yup2) => yup2.object());
   }
   supportsSeeding() {
     return false;
@@ -404,8 +241,8 @@ var FilesystemStore = class {
     return false;
   }
   async glob(pattern, callback) {
-    const basePath = import_path4.default.join(this.rootPath, ...pattern.split("/"));
-    const itemsRaw = await (0, import_fast_glob2.default)(import_path4.default.join(basePath, "**", "/*").replace(/\\/g, "/"), {
+    const basePath = import_path2.default.join(this.rootPath, ...pattern.split("/"));
+    const itemsRaw = await (0, import_fast_glob2.default)(import_path2.default.join(basePath, "**", "/*").replace(/\\/g, "/"), {
       dot: true
     });
     const posixRootPath = (0, import_normalize_path2.default)(this.rootPath);
@@ -420,125 +257,454 @@ var FilesystemStore = class {
       return items;
     }
   }
-  async put(filepath, data) {
-    await import_fs_extra2.default.outputFileSync(import_path4.default.join(this.rootPath, filepath), stringifyFile(data, import_path4.default.extname(filepath), false));
-  }
-};
-
-// pnp:/Users/jeffsee/code/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();
-      }
-    };
+  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 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)));
-    }
-    return sequential(items, async (documentString) => {
-      return hydrator(documentString);
-    });
+  async open() {
   }
-  async seed(filepath, data) {
-    await this.put(filepath, data);
+  async close() {
   }
-  supportsSeeding() {
-    return true;
+  async delete(filepath) {
+    await import_fs_extra2.default.remove(import_path2.default.join(this.rootPath, filepath));
   }
-  supportsIndexing() {
-    return true;
+};
+var AuditFilesystemStore = class extends FilesystemStore {
+  async put(_filepath, _data) {
+    return;
   }
-  async 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 clear() {
-    this.map = {};
+};
+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}'`);
+      }
+    }
   }
-  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") {
+        operands = resolvedValues.map((resolvedValue) => Number(resolvedValue));
+      } else if (dataType === "datetime") {
+        operands = resolvedValues.map((resolvedValue) => {
+          const coerced = new Date(resolvedValue).getTime();
+          return isNaN(coerced) ? Number(resolvedValue) : coerced;
+        });
+      } 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:/Users/jeffsee/code/tinacms/packages/@tinacms/datalayer/src/database/store/level.ts
-var import_path5 = __toModule(require("path"));
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/database/store/level.ts
+var import_path3 = __toModule(require("path"));
 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_path5.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;
@@ -546,6 +712,27 @@ var LevelStore = class {
   supportsIndexing() {
     return true;
   }
+  async delete(filepath, options) {
+    const data = await this.db.get(`${defaultPrefix}${INDEX_KEY_FIELD_SEPARATOR}${filepath}`);
+    if (!data) {
+      return;
+    }
+    if (options == null ? void 0 : options.indexDefinitions) {
+      for (const [sort, definition] of Object.entries(options.indexDefinitions)) {
+        const indexedValue = makeKeyForField(definition, data, escapeStr);
+        let indexKey;
+        if (sort === DEFAULT_COLLECTION_SORT_KEY) {
+          indexKey = `${options.collection}${INDEX_KEY_FIELD_SEPARATOR}${sort}${INDEX_KEY_FIELD_SEPARATOR}${filepath}`;
+        } else {
+          indexKey = indexedValue ? `${options.collection}${INDEX_KEY_FIELD_SEPARATOR}${sort}${INDEX_KEY_FIELD_SEPARATOR}${indexedValue}${INDEX_KEY_FIELD_SEPARATOR}${filepath}` : null;
+        }
+        if (indexKey) {
+          await this.db.del(indexKey);
+        }
+      }
+    }
+    await this.db.del(`${defaultPrefix}${INDEX_KEY_FIELD_SEPARATOR}${filepath}`);
+  }
   async print() {
     this.db.createReadStream().on("data", function(data) {
       console.log(data.key, "=", data.value);
@@ -567,10 +754,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() {
@@ -588,22 +775,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,
-  GithubBridge,
-  GithubStore,
+  INDEX_KEY_FIELD_SEPARATOR,
   LevelStore,
-  MemoryStore
+  OP,
+  atob,
+  btoa,
+  coerceFilterChainOperands,
+  makeFilter,
+  makeFilterChain,
+  makeFilterSuffixes,
+  makeKeyForField,
+  makeStringEscaper
 });