@tinacms/graphql 1.1.0 → 1.2.0

package/dist/index.js

@@ -39,22 +39,26 @@ var __export = (target, all) => {
   for (var name2 in all)
     __defProp(target, name2, { get: all[name2], enumerable: true });
 };
-var __reExport = (target, module2, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
+var __reExport = (target, module3, desc) => {
+  if (module3 && typeof module3 === "object" || typeof module3 === "function") {
+    for (let key of __getOwnPropNames(module3))
       if (!__hasOwnProp.call(target, key) && key !== "default")
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+        __defProp(target, key, { get: () => module3[key], enumerable: !(desc = __getOwnPropDesc(module3, key)) || desc.enumerable });
   }
   return target;
 };
-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);
+var __toModule = (module3) => {
+  return __reExport(__markAsModule(__defProp(module3 != null ? __create(__getProtoOf(module3)) : {}, "default", module3 && module3.__esModule && "default" in module3 ? { get: () => module3.default, enumerable: true } : { value: module3, enumerable: true })), module3);
 };
 
 // src/index.ts
 __export(exports, {
+  AuditFileSystemBridge: () => AuditFileSystemBridge,
+  FilesystemBridge: () => FilesystemBridge,
+  IsomorphicBridge: () => IsomorphicBridge,
   TinaFetchError: () => TinaFetchError,
   TinaGraphQLError: () => TinaGraphQLError,
+  TinaLevelClient: () => TinaLevelClient,
   TinaParseDocumentError: () => TinaParseDocumentError,
   TinaQueryError: () => TinaQueryError,
   assertShape: () => assertShape,
@@ -69,9 +73,9 @@ __export(exports, {
   sequential: () => sequential,
   stringifyFile: () => stringifyFile
 });
-var import_fs_extra2 = __toModule(require("fs-extra"));
-var import_path4 = __toModule(require("path"));
-var import_graphql6 = __toModule(require("graphql"));
+var import_fs_extra4 = __toModule(require("fs-extra"));
+var import_path6 = __toModule(require("path"));
+var import_graphql7 = __toModule(require("graphql"));
 
 // src/build.ts
 var import_lodash3 = __toModule(require("lodash"));
@@ -113,6 +117,12 @@ function assertShape(value, yupSchema, errorMessage) {
     });
   }
 }
+var atob = (b64Encoded) => {
+  return Buffer.from(b64Encoded, "base64").toString();
+};
+var btoa = (string2) => {
+  return Buffer.from(string2).toString("base64");
+};
 var lastItem = (arr) => {
   return arr[arr.length - 1];
 };
@@ -2186,14 +2196,14 @@ var Builder = class {
       collection,
       collections
     }) => {
-      const extra = this.database.store.supportsIndexing() ? [
+      const extra = [
         await this._connectionFilterBuilder({
           fieldName,
           namespace,
           collection,
           collections
         })
-      ] : [];
+      ];
       return astBuilder.FieldDefinition({
         name: fieldName,
         required: true,
@@ -2473,14 +2483,19 @@ var validateField = async (field) => {
 
 // package.json
 var name = "@tinacms/graphql";
-var version = "1.1.0";
+var version = "1.2.0";
 var main = "dist/index.js";
+var module2 = "dist/index.es.js";
 var typings = "dist/index.d.ts";
 var files = [
   "package.json",
   "dist"
 ];
-var license = "Apache-2.0";
+var exports = {
+  import: "./dist/index.es.js",
+  require: "./dist/index.js"
+};
+var license = "SEE LICENSE IN LICENSE";
 var buildConfig = {
   entryPoints: [
     {
@@ -2501,9 +2516,9 @@ var scripts = {
 var dependencies = {
   "@graphql-tools/relay-operation-optimizer": "^6.4.1",
   "@iarna/toml": "^2.2.5",
-  "@tinacms/datalayer": "workspace:*",
   "@tinacms/mdx": "workspace:*",
   "@tinacms/schema-tools": "workspace:*",
+  "abstract-level": "^1.0.3",
   "body-parser": "^1.19.0",
   cors: "^2.8.5",
   dataloader: "^2.0.0",
@@ -2515,12 +2530,16 @@ var dependencies = {
   "fast-glob": "^3.2.5",
   flat: "^5.0.2",
   "fs-extra": "^9.0.1",
+  "glob-parent": "^6.0.2",
   graphql: "15.8.0",
   "graphql-type-json": "^0.3.2",
   "gray-matter": "^4.0.2",
+  "isomorphic-git": "^1.21.0",
   "js-yaml": "^3.14.1",
+  "jsonpath-plus": "^6.0.1",
   leveldown: "^6.1.0",
   lodash: "^4.17.20",
+  "many-level": "^2.0.0",
   mdast: "^3.0.0",
   "mdast-util-from-markdown": "^1.0.0",
   "mdast-util-mdx": "^1.1.0",
@@ -2529,6 +2548,7 @@ var dependencies = {
   "micromark-extension-mdxjs": "^1.0.0",
   "normalize-path": "^3.0.0",
   prettier: "^2.2.1",
+  "readable-stream": "^4.3.0",
   "rehype-format": "^3.1.0",
   "rehype-stringify": "^8.0.0",
   remark: "^13.0.0",
@@ -2553,7 +2573,6 @@ var repository = {
   directory: "packages/tina-graphql"
 };
 var devDependencies = {
-  "@tinacms/datalayer": "workspace:*",
   "@tinacms/schema-tools": "workspace:*",
   "@tinacms/scripts": "workspace:*",
   "@types/cors": "^2.8.7",
@@ -2575,6 +2594,7 @@ var devDependencies = {
   "jest-diff": "27.0.6",
   "jest-file-snapshot": "^0.5.0",
   "jest-matcher-utils": "27.0.6",
+  "memory-level": "^1.0.0",
   nodemon: "2.0.19",
   typescript: "4.3.5"
 };
@@ -2582,8 +2602,10 @@ var package_default = {
   name,
   version,
   main,
+  module: module2,
   typings,
   files,
+  exports,
   license,
   buildConfig,
   scripts,
@@ -2623,10 +2645,8 @@ var buildDotTinaFiles = async ({
   flags = [],
   buildSDK = true
 }) => {
-  if (database.store.supportsIndexing()) {
-    if (flags.indexOf("experimentalData") === -1) {
-      flags.push("experimentalData");
-    }
+  if (flags.indexOf("experimentalData") === -1) {
+    flags.push("experimentalData");
   }
   const tinaSchema = await createSchema({ schema: config, flags });
   const builder = await createBuilder({
@@ -2800,9 +2820,6 @@ var handleFetchErrorError = (e, verbose) => {
   throw e;
 };
 
-// src/resolver/index.ts
-var import_datalayer = __toModule(require("@tinacms/datalayer"));
-
 // src/resolver/filter-utils.ts
 var resolveReferences = async (filter, fields, resolver) => {
   for (const fieldKey of Object.keys(filter)) {
@@ -2931,9 +2948,9 @@ var resolveMediaRelativeToCloud = (value, config = { useRelativeMedia: true }, s
     return value;
   }
 };
-var cleanUpSlashes = (path5) => {
-  if (path5) {
-    return `/${path5.replace(/^\/+|\/+$/gm, "")}`;
+var cleanUpSlashes = (path6) => {
+  if (path6) {
+    return `/${path6.replace(/^\/+|\/+$/gm, "")}`;
   }
   return "";
 };
@@ -2947,6 +2964,389 @@ var hasTinaMediaConfig = (schema) => {
 
 // src/resolver/index.ts
 var import_graphql3 = __toModule(require("graphql"));
+
+// src/database/datalayer.ts
+var import_jsonpath_plus = __toModule(require("jsonpath-plus"));
+
+// src/database/level.ts
+var INDEX_KEY_FIELD_SEPARATOR = "";
+var CONTENT_ROOT_PREFIX = "~";
+var SUBLEVEL_OPTIONS = {
+  separator: INDEX_KEY_FIELD_SEPARATOR,
+  valueEncoding: "json"
+};
+
+// src/database/datalayer.ts
+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 DEFAULT_COLLECTION_SORT_KEY = "__filepath__";
+var DEFAULT_NUMERIC_LPAD = 4;
+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);
+    }
+  }
+  return input;
+};
+var getFilterOperator = (expression, operand) => {
+  return (expression[operand] || expression[operand] === 0) && operand;
+};
+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}'`);
+  }
+};
+var makeKeyForField = (definition, data, stringEscaper2, maxStringLength = 100) => {
+  const valueParts = [];
+  for (const field of definition.fields) {
+    if (field.name in data && data[field.name] !== void 0 && data[field.name] !== null) {
+      const rawValue = data[field.name];
+      const resolvedValue = String(field.type === "datetime" ? new Date(rawValue).getTime() : field.type === "string" ? stringEscaper2(rawValue) : rawValue).substring(0, maxStringLength);
+      valueParts.push(applyPadding(resolvedValue, field.pad));
+    } else {
+      return null;
+    }
+  }
+  return valueParts.join(INDEX_KEY_FIELD_SEPARATOR);
+};
+var coerceFilterChainOperands = (filterChain, escapeString = 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(escapeString(filter.rightOperand), filter.pad),
+            leftOperand: applyPadding(escapeString(filter.leftOperand), filter.pad)
+          }));
+        } else {
+          result.push(__spreadProps(__spreadValues({}, filter), {
+            rightOperand: applyPadding(escapeString(filter.rightOperand), filter.pad)
+          }));
+        }
+      } else {
+        result.push(__spreadValues({}, filter));
+      }
+    }
+  }
+  return result;
+};
+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;
+      }
+    }
+    return true;
+  };
+};
+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 filterChain;
+};
+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 makeIndexOpsForDocument = (filepath, collection, indexDefinitions, data, opType, level, escapeStr = stringEscaper) => {
+  const result = [];
+  if (collection) {
+    const collectionSublevel = level.sublevel(collection, SUBLEVEL_OPTIONS);
+    for (const [sort, definition] of Object.entries(indexDefinitions)) {
+      const indexedValue = makeKeyForField(definition, data, escapeStr);
+      const indexSublevel = collectionSublevel.sublevel(sort, SUBLEVEL_OPTIONS);
+      if (sort === DEFAULT_COLLECTION_SORT_KEY) {
+        result.push({
+          type: opType,
+          key: filepath,
+          sublevel: indexSublevel,
+          value: opType === "put" ? {} : void 0
+        });
+      } else {
+        if (indexedValue) {
+          result.push({
+            type: opType,
+            key: `${indexedValue}${INDEX_KEY_FIELD_SEPARATOR}${filepath}`,
+            sublevel: indexSublevel,
+            value: opType === "put" ? {} : void 0
+          });
+        }
+      }
+    }
+  }
+  return result;
+};
+var makeStringEscaper = (regex, replacement) => {
+  return (input) => {
+    if (Array.isArray(input)) {
+      return input.map((val) => val.replace(regex, replacement));
+    } else {
+      return input.replace(regex, replacement);
+    }
+  };
+};
+var stringEscaper = makeStringEscaper(new RegExp(INDEX_KEY_FIELD_SEPARATOR, "gm"), encodeURIComponent(INDEX_KEY_FIELD_SEPARATOR));
+
+// src/resolver/index.ts
 var createResolver = (args) => {
   return new Resolver(args);
 };
@@ -3250,7 +3650,7 @@ var Resolver = class {
           first: -1
         },
         collection: referencedCollection,
-        hydrator: (path5) => path5
+        hydrator: (path6) => path6
       });
       const { edges } = resolvedCollectionConnection;
       const values = edges.map((edge) => edge.node);
@@ -3277,7 +3677,7 @@ var Resolver = class {
         }
       }
       const queryOptions = {
-        filterChain: (0, import_datalayer.makeFilterChain)({
+        filterChain: makeFilterChain({
           conditions: conditions || []
         }),
         collection: collection.name,
@@ -3518,7 +3918,7 @@ var resolve = async ({
         }
       },
       fieldResolver: async (source = {}, _args = {}, _context, info) => {
-        var _a2;
+        var _a2, _b, _c, _d;
         try {
           const args = JSON.parse(JSON.stringify(_args));
           const returnType = (0, import_graphql4.getNamedType)(info.returnType).toString();
@@ -3607,8 +4007,14 @@ var resolve = async ({
                   })
                 };
               } else if (info.fieldName === "documents" && (value == null ? void 0 : value.collection) && (value == null ? void 0 : value.hasDocuments)) {
+                let filter = args.filter;
+                if (typeof (args == null ? void 0 : args.filter) !== "undefined" && (args == null ? void 0 : args.filter) !== null && typeof ((_b = value == null ? void 0 : value.collection) == null ? void 0 : _b.name) === "string" && Object.keys(args.filter).includes((_c = value == null ? void 0 : value.collection) == null ? void 0 : _c.name) && typeof args.filter[(_d = value == null ? void 0 : value.collection) == null ? void 0 : _d.name] !== "undefined") {
+                  filter = args.filter[value.collection.name];
+                }
                 return resolver.resolveCollectionConnection({
-                  args,
+                  args: __spreadProps(__spreadValues({}, args), {
+                    filter
+                  }),
                   collection: value.collection
                 });
               } else {
@@ -3776,31 +4182,32 @@ var parseFile = (content, format, yupSchema, markdownParseConfig) => {
 var normalizePath = (filepath) => filepath.replace(/\\/g, "/");
 
 // src/database/index.ts
-var import_datalayer2 = __toModule(require("@tinacms/datalayer"));
-var createDatabase = async (config) => {
+var createDatabase = (config) => {
   return new Database(__spreadProps(__spreadValues({}, config), {
     bridge: config.bridge,
-    store: config.store
+    level: config.level
   }));
 };
 var SYSTEM_FILES = ["_schema", "_graphql", "_lookup"];
 var defaultStatusCallback = () => Promise.resolve();
+var defaultOnPut = () => Promise.resolve();
+var defaultOnDelete = () => Promise.resolve();
 var Database = class {
   constructor(config) {
     this.config = config;
     this.collectionForPath = async (filepath) => {
-      const tinaSchema = await this.getSchema();
-      const collection = tinaSchema.getCollectionByFullPath(filepath);
-      return collection;
+      const tinaSchema = await this.getSchema(this.level);
+      return tinaSchema.getCollectionByFullPath(filepath);
     };
     this.getGeneratedFolder = () => import_path3.default.join(this.tinaDirectory, "__generated__");
     this.get = async (filepath) => {
+      await this.initLevel();
       if (SYSTEM_FILES.includes(filepath)) {
         throw new Error(`Unexpected get for config file ${filepath}`);
       } else {
-        const tinaSchema = await this.getSchema();
+        const tinaSchema = await this.getSchema(this.level);
         const extension = import_path3.default.extname(filepath);
-        const contentObject = await this.store.get(normalizePath(filepath));
+        const contentObject = await this.level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS).get(normalizePath(filepath));
         if (!contentObject) {
           throw new import_graphql5.GraphQLError(`Unable to find record ${filepath}`);
         }
@@ -3832,41 +4239,79 @@ var Database = class {
       }
     };
     this.addPendingDocument = async (filepath, data) => {
-      const { stringifiedFile, payload, keepTemplateKey } = await this.stringifyFile(filepath, data);
+      await this.initLevel();
+      const { stringifiedFile, payload } = await this.stringifyFile(filepath, data);
       const collection = await this.collectionForPath(filepath);
       let collectionIndexDefinitions;
       if (collection) {
-        const indexDefinitions = await this.getIndexDefinitions();
+        const indexDefinitions = await this.getIndexDefinitions(this.level);
         collectionIndexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[collection.name];
       }
-      if (this.store.supportsSeeding()) {
-        await this.bridge.put(normalizePath(filepath), stringifiedFile);
+      const normalizedPath = normalizePath(filepath);
+      if (this.bridge) {
+        await this.bridge.put(normalizedPath, stringifiedFile);
       }
-      await this.store.put(normalizePath(filepath), payload, {
-        keepTemplateKey,
-        collection: collection == null ? void 0 : collection.name,
-        indexDefinitions: collectionIndexDefinitions
-      });
+      await this.onPut(normalizedPath, stringifiedFile);
+      const putOps = makeIndexOpsForDocument(normalizedPath, collection == null ? void 0 : collection.name, collectionIndexDefinitions, payload, "put", this.level);
+      let existingItem;
+      try {
+        existingItem = await this.level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS).get(normalizedPath);
+      } catch (e) {
+        if (e.code !== "LEVEL_NOT_FOUND") {
+          throw e;
+        }
+      }
+      const delOps = existingItem ? makeIndexOpsForDocument(normalizedPath, collection == null ? void 0 : collection.name, collectionIndexDefinitions, existingItem, "del", this.level) : [];
+      const ops = [
+        ...delOps,
+        ...putOps,
+        {
+          type: "put",
+          key: normalizedPath,
+          value: payload,
+          sublevel: this.level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS)
+        }
+      ];
+      await this.level.batch(ops);
     };
     this.put = async (filepath, data, collection) => {
+      await this.initLevel();
       try {
         if (SYSTEM_FILES.includes(filepath)) {
           throw new Error(`Unexpected put for config file ${filepath}`);
         } else {
           let collectionIndexDefinitions;
           if (collection) {
-            const indexDefinitions = await this.getIndexDefinitions();
+            const indexDefinitions = await this.getIndexDefinitions(this.level);
             collectionIndexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[collection];
           }
-          const { stringifiedFile, payload, keepTemplateKey } = await this.stringifyFile(filepath, data);
-          if (this.store.supportsSeeding()) {
-            await this.bridge.put(normalizePath(filepath), stringifiedFile);
+          const normalizedPath = normalizePath(filepath);
+          const { stringifiedFile, payload } = await this.stringifyFile(filepath, data);
+          if (this.bridge) {
+            await this.bridge.put(normalizedPath, stringifiedFile);
           }
-          await this.store.put(normalizePath(filepath), payload, {
-            keepTemplateKey,
-            collection,
-            indexDefinitions: collectionIndexDefinitions
-          });
+          await this.onPut(normalizedPath, stringifiedFile);
+          const putOps = makeIndexOpsForDocument(normalizedPath, collection, collectionIndexDefinitions, payload, "put", this.level);
+          let existingItem;
+          try {
+            existingItem = await this.level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS).get(normalizedPath);
+          } catch (e) {
+            if (e.code !== "LEVEL_NOT_FOUND") {
+              throw e;
+            }
+          }
+          const delOps = existingItem ? makeIndexOpsForDocument(normalizedPath, collection, collectionIndexDefinitions, existingItem, "del", this.level) : [];
+          const ops = [
+            ...delOps,
+            ...putOps,
+            {
+              type: "put",
+              key: normalizedPath,
+              value: payload,
+              sublevel: this.level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS)
+            }
+          ];
+          await this.level.batch(ops);
         }
         return true;
       } catch (error) {
@@ -3882,7 +4327,7 @@ var Database = class {
       if (SYSTEM_FILES.includes(filepath)) {
         throw new Error(`Unexpected put for config file ${filepath}`);
       } else {
-        const tinaSchema = await this.getSchema();
+        const tinaSchema = await this.getSchema(this.level);
         const collection = tinaSchema.getCollectionByFullPath(filepath);
         const templateInfo = await tinaSchema.getTemplatesForCollectable(collection);
         let template;
@@ -3936,43 +4381,51 @@ var Database = class {
       return stringifiedFile;
     };
     this.getLookup = async (returnType) => {
-      const lookupPath = import_path3.default.join(this.getGeneratedFolder(), `_lookup.json`);
+      await this.initLevel();
+      const lookupPath = normalizePath(import_path3.default.join(this.getGeneratedFolder(), `_lookup.json`));
       if (!this._lookup) {
-        const _lookup = await this.store.get(normalizePath(lookupPath));
+        const _lookup = await this.level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS).get(lookupPath);
         this._lookup = _lookup;
       }
       return this._lookup[returnType];
     };
     this.getGraphQLSchema = async () => {
-      const graphqlPath = import_path3.default.join(this.getGeneratedFolder(), `_graphql.json`);
-      return this.store.get(normalizePath(graphqlPath));
+      await this.initLevel();
+      const graphqlPath = normalizePath(import_path3.default.join(this.getGeneratedFolder(), `_graphql.json`));
+      return await this.level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS).get(graphqlPath);
     };
     this.getGraphQLSchemaFromBridge = async () => {
-      const graphqlPath = import_path3.default.join(this.getGeneratedFolder(), `_graphql.json`);
-      const _graphql = await this.bridge.get(normalizePath(graphqlPath));
+      if (!this.bridge) {
+        throw new Error(`No bridge configured`);
+      }
+      const graphqlPath = normalizePath(import_path3.default.join(this.getGeneratedFolder(), `_graphql.json`));
+      const _graphql = await this.bridge.get(graphqlPath);
       return JSON.parse(_graphql);
     };
-    this.getTinaSchema = async () => {
-      const schemaPath = import_path3.default.join(this.getGeneratedFolder(), `_schema.json`);
-      return this.store.get(normalizePath(schemaPath));
+    this.getTinaSchema = async (level) => {
+      await this.initLevel();
+      const schemaPath = normalizePath(import_path3.default.join(this.getGeneratedFolder(), `_schema.json`));
+      return await (level || this.level).sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS).get(schemaPath);
     };
-    this.getSchema = async () => {
+    this.getSchema = async (level) => {
       if (this.tinaSchema) {
         return this.tinaSchema;
       }
-      const schema = await this.getTinaSchema();
+      await this.initLevel();
+      const schema = await this.getTinaSchema(level || this.level);
       this.tinaSchema = await createSchema({ schema });
       return this.tinaSchema;
     };
-    this.getIndexDefinitions = async () => {
+    this.getIndexDefinitions = async (level) => {
       if (!this.collectionIndexDefinitions) {
         await new Promise(async (resolve2, reject) => {
+          await this.initLevel();
           try {
-            const schema = await this.getSchema();
+            const schema = await this.getSchema(level || this.level);
             const collections = schema.getCollections();
             for (const collection of collections) {
               const indexDefinitions = {
-                [import_datalayer2.DEFAULT_COLLECTION_SORT_KEY]: { fields: [] }
+                [DEFAULT_COLLECTION_SORT_KEY]: { fields: [] }
               };
               if (collection.fields) {
                 for (const field of collection.fields) {
@@ -3984,7 +4437,7 @@ var Database = class {
                       {
                         name: field.name,
                         type: field.type,
-                        pad: field.type === "number" ? { fillString: "0", maxLength: import_datalayer2.DEFAULT_NUMERIC_LPAD } : void 0
+                        pad: field.type === "number" ? { fillString: "0", maxLength: DEFAULT_NUMERIC_LPAD } : void 0
                       }
                     ]
                   };
@@ -4023,43 +4476,82 @@ var Database = class {
       return true;
     };
     this.query = async (queryOptions, hydrator) => {
-      const { first, after, last, before, sort, collection, filterChain } = queryOptions;
-      const storeQueryOptions = {
-        sort,
+      var _a;
+      await this.initLevel();
+      const {
+        first,
+        after,
+        last,
+        before,
+        sort = DEFAULT_COLLECTION_SORT_KEY,
         collection,
-        filterChain
-      };
+        filterChain: rawFilterChain
+      } = queryOptions;
+      let limit = 50;
       if (first) {
-        storeQueryOptions.limit = first;
+        limit = first;
       } else if (last) {
-        storeQueryOptions.limit = last;
-      } else {
-        storeQueryOptions.limit = 50;
+        limit = last;
       }
+      const query = { reverse: !!last };
       if (after) {
-        storeQueryOptions.gt = (0, import_datalayer2.atob)(after);
+        query.gt = atob(after);
       } else if (before) {
-        storeQueryOptions.lt = (0, import_datalayer2.atob)(before);
-      }
-      if (last) {
-        storeQueryOptions.reverse = true;
+        query.lt = atob(before);
       }
-      const indexDefinitions = await this.getIndexDefinitions();
-      storeQueryOptions.indexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[queryOptions.collection];
-      if (!storeQueryOptions.indexDefinitions) {
+      const allIndexDefinitions = await this.getIndexDefinitions(this.level);
+      const indexDefinitions = allIndexDefinitions == null ? void 0 : allIndexDefinitions[queryOptions.collection];
+      if (!indexDefinitions) {
         throw new Error(`No indexDefinitions for collection ${queryOptions.collection}`);
       }
-      const {
-        edges,
-        pageInfo: { hasPreviousPage, hasNextPage, startCursor, endCursor }
-      } = await this.store.query(storeQueryOptions);
+      const filterChain = coerceFilterChainOperands(rawFilterChain);
+      const indexDefinition = sort && (indexDefinitions == null ? void 0 : indexDefinitions[sort]);
+      const filterSuffixes = indexDefinition && makeFilterSuffixes(filterChain, indexDefinition);
+      const rootLevel = this.level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS);
+      const sublevel = indexDefinition ? this.level.sublevel(collection, SUBLEVEL_OPTIONS).sublevel(sort, SUBLEVEL_OPTIONS) : rootLevel;
+      if (!query.gt && !query.gte) {
+        query.gte = (filterSuffixes == null ? void 0 : filterSuffixes.left) ? filterSuffixes.left : "";
+      }
+      if (!query.lt && !query.lte) {
+        query.lte = (filterSuffixes == null ? void 0 : filterSuffixes.right) ? `${filterSuffixes.right}\xFF` : "\xFF";
+      }
+      let edges = [];
+      let startKey = "";
+      let endKey = "";
+      let hasPreviousPage = false;
+      let hasNextPage = false;
+      const fieldsPattern = ((_a = indexDefinition == null ? void 0 : indexDefinition.fields) == null ? void 0 : _a.length) ? `${indexDefinition.fields.map((p) => `(?<${p.name}>.+)${INDEX_KEY_FIELD_SEPARATOR}`).join("")}` : "";
+      const valuesRegex = indexDefinition ? new RegExp(`^${fieldsPattern}(?<_filepath_>.+)`) : new RegExp(`^(?<_filepath_>.+)`);
+      const itemFilter = makeFilter({ filterChain });
+      const iterator = sublevel.iterator(query);
+      for await (const [key, value] of iterator) {
+        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 rootLevel.get(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: await sequential(edges, async (edge) => {
           try {
             const node = await hydrator(edge.path);
             return {
               node,
-              cursor: (0, import_datalayer2.btoa)(edge.cursor)
+              cursor: btoa(edge.cursor)
             };
           } catch (error) {
             if (error instanceof Error && (!edge.path.includes(".tina/__generated__/_graphql.json") || !edge.path.includes("tina/__generated__/_graphql.json"))) {
@@ -4077,8 +4569,8 @@ var Database = class {
         pageInfo: {
           hasPreviousPage,
           hasNextPage,
-          startCursor: (0, import_datalayer2.btoa)(startCursor),
-          endCursor: (0, import_datalayer2.btoa)(endCursor)
+          startCursor: btoa(startKey),
+          endCursor: btoa(endKey)
         }
       };
     };
@@ -4086,7 +4578,7 @@ var Database = class {
       graphQLSchema,
       tinaSchema
     }) => {
-      if (this.bridge.supportsBuilding()) {
+      if (this.bridge && this.bridge.supportsBuilding()) {
         await this.bridge.putConfig(normalizePath(import_path3.default.join(this.getGeneratedFolder(), `_graphql.json`)), JSON.stringify(graphQLSchema));
         await this.bridge.putConfig(normalizePath(import_path3.default.join(this.getGeneratedFolder(), `_schema.json`)), JSON.stringify(tinaSchema.schema));
       }
@@ -4096,60 +4588,125 @@ var Database = class {
       tinaSchema,
       lookup: lookupFromLockFile
     }) => {
+      if (!this.bridge) {
+        throw new Error("No bridge configured");
+      }
+      await this.initLevel();
       await this.indexStatusCallbackWrapper(async () => {
         const lookup = lookupFromLockFile || JSON.parse(await this.bridge.get(normalizePath(import_path3.default.join(this.getGeneratedFolder(), "_lookup.json"))));
-        if (this.store.supportsSeeding()) {
-          await this.store.clear();
-          await this.store.seed(normalizePath(import_path3.default.join(this.getGeneratedFolder(), "_graphql.json")), graphQLSchema);
-          await this.store.seed(normalizePath(import_path3.default.join(this.getGeneratedFolder(), "_schema.json")), tinaSchema.schema);
-          await this.store.seed(normalizePath(import_path3.default.join(this.getGeneratedFolder(), "_lookup.json")), lookup);
-          await this._indexAllContent();
+        let nextLevel;
+        let nextVersion;
+        if (!this.config.version) {
+          await this.level.clear();
+          nextLevel = this.level;
         } else {
-          if (this.store.supportsIndexing()) {
-            throw new Error(`Schema must be indexed with provided Store`);
+          const version2 = await this.getDatabaseVersion();
+          nextVersion = version2 ? `${parseInt(version2) + 1}` : "0";
+          nextLevel = this.rootLevel.sublevel(nextVersion, SUBLEVEL_OPTIONS);
+        }
+        const contentRootLevel = nextLevel.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS);
+        await contentRootLevel.put(normalizePath(import_path3.default.join(this.getGeneratedFolder(), "_graphql.json")), graphQLSchema);
+        await contentRootLevel.put(normalizePath(import_path3.default.join(this.getGeneratedFolder(), "_schema.json")), tinaSchema.schema);
+        await contentRootLevel.put(normalizePath(import_path3.default.join(this.getGeneratedFolder(), "_lookup.json")), lookup);
+        await this._indexAllContent(nextLevel);
+        if (this.config.version) {
+          await this.updateDatabaseVersion(nextVersion);
+          if (this.level) {
+            await this.level.clear();
           }
+          this.level = nextLevel;
         }
       });
     };
     this.deleteContentByPaths = async (documentPaths) => {
+      await this.initLevel();
+      const operations = [];
+      const enqueueOps = async (ops) => {
+        operations.push(...ops);
+        while (operations.length >= 25) {
+          await this.level.batch(operations.splice(0, 25));
+        }
+      };
       await this.indexStatusCallbackWrapper(async () => {
         const { pathsByCollection, nonCollectionPaths, collections } = await this.partitionPathsByCollection(documentPaths);
         for (const collection of Object.keys(pathsByCollection)) {
-          await _deleteIndexContent(this, pathsByCollection[collection], collections[collection]);
+          await _deleteIndexContent(this, pathsByCollection[collection], enqueueOps, collections[collection]);
         }
-        await _deleteIndexContent(this, nonCollectionPaths, null);
+        await _deleteIndexContent(this, nonCollectionPaths, enqueueOps, null);
       });
+      while (operations.length) {
+        await this.level.batch(operations.splice(0, 25));
+      }
     };
     this.indexContentByPaths = async (documentPaths) => {
+      await this.initLevel();
+      const operations = [];
+      const enqueueOps = async (ops) => {
+        operations.push(...ops);
+        while (operations.length >= 25) {
+          await this.level.batch(operations.splice(0, 25));
+        }
+      };
       await this.indexStatusCallbackWrapper(async () => {
         const { pathsByCollection, nonCollectionPaths, collections } = await this.partitionPathsByCollection(documentPaths);
         for (const collection of Object.keys(pathsByCollection)) {
-          await _indexContent(this, pathsByCollection[collection], collections[collection]);
+          await _indexContent(this, this.level, pathsByCollection[collection], enqueueOps, collections[collection]);
         }
-        await _indexContent(this, nonCollectionPaths);
+        await _indexContent(this, this.level, nonCollectionPaths, enqueueOps);
       });
+      while (operations.length) {
+        await this.level.batch(operations.splice(0, 25));
+      }
     };
     this.delete = async (filepath) => {
+      await this.initLevel();
       const collection = await this.collectionForPath(filepath);
       let collectionIndexDefinitions;
       if (collection) {
-        const indexDefinitions = await this.getIndexDefinitions();
+        const indexDefinitions = await this.getIndexDefinitions(this.level);
         collectionIndexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[collection.name];
       }
-      await this.store.delete(normalizePath(filepath), {
-        collection: collection.name,
-        indexDefinitions: collectionIndexDefinitions
-      });
-      await this.bridge.delete(normalizePath(filepath));
+      this.level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS);
+      const itemKey = normalizePath(filepath);
+      const rootSublevel = this.level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS);
+      const item = await rootSublevel.get(itemKey);
+      if (item) {
+        await this.level.batch([
+          ...makeIndexOpsForDocument(filepath, collection.name, collectionIndexDefinitions, item, "del", this.level),
+          {
+            type: "del",
+            key: itemKey,
+            sublevel: rootSublevel
+          }
+        ]);
+      }
+      if (this.bridge) {
+        await this.bridge.delete(normalizePath(filepath));
+      }
+      await this.onDelete(normalizePath(filepath));
     };
-    this._indexAllContent = async () => {
-      const tinaSchema = await this.getSchema();
+    this._indexAllContent = async (level) => {
+      const tinaSchema = await this.getSchema(level);
+      const operations = [];
+      const enqueueOps = async (ops) => {
+        operations.push(...ops);
+        while (operations.length >= 25) {
+          const batchOps = operations.splice(0, 25);
+          await level.batch(batchOps);
+        }
+      };
       await sequential(tinaSchema.getCollections(), async (collection) => {
         const documentPaths = await this.bridge.glob(normalizePath(collection.path), collection.format || "md");
-        await _indexContent(this, documentPaths, collection);
+        await _indexContent(this, level, documentPaths, enqueueOps, collection);
       });
+      while (operations.length) {
+        await level.batch(operations.splice(0, 25));
+      }
     };
     this.addToLookupMap = async (lookup) => {
+      if (!this.bridge) {
+        throw new Error("No bridge configured");
+      }
       const lookupPath = import_path3.default.join(this.getGeneratedFolder(), `_lookup.json`);
       let lookupMap;
       try {
@@ -4164,8 +4721,10 @@ var Database = class {
     };
     this.tinaDirectory = config.tinaDirectory || ".tina";
     this.bridge = config.bridge;
-    this.store = config.store;
+    this.rootLevel = config.level;
     this.indexStatusCallback = config.indexStatusCallback || defaultStatusCallback;
+    this.onPut = config.onPut || defaultOnPut;
+    this.onDelete = config.onDelete || defaultOnDelete;
   }
   async partitionPathsByCollection(documentPaths) {
     const pathsByCollection = {};
@@ -4185,6 +4744,39 @@ var Database = class {
     }
     return { pathsByCollection, nonCollectionPaths, collections };
   }
+  async updateDatabaseVersion(version2) {
+    const metadataLevel = await this.rootLevel.sublevel("_metadata", SUBLEVEL_OPTIONS);
+    await metadataLevel.put("metadata", { version: version2 });
+  }
+  async getDatabaseVersion() {
+    const metadataLevel = await this.rootLevel.sublevel("_metadata", SUBLEVEL_OPTIONS);
+    let version2;
+    try {
+      const metadata = await metadataLevel.get("metadata");
+      version2 = metadata.version || version2;
+    } catch (e) {
+      if (e.code !== "LEVEL_NOT_FOUND") {
+        throw e;
+      }
+      if (version2) {
+        await metadataLevel.put("metadata", { version: version2 });
+      }
+    }
+    return version2;
+  }
+  async initLevel() {
+    if (this.level) {
+      return;
+    }
+    if (!this.config.version) {
+      this.level = this.rootLevel;
+    } else {
+      const version2 = await this.getDatabaseVersion();
+      if (version2) {
+        this.level = this.rootLevel.sublevel(version2, SUBLEVEL_OPTIONS);
+      }
+    }
+  }
   clearCache() {
     this.tinaSchema = null;
     this._lookup = null;
@@ -4203,22 +4795,14 @@ var Database = class {
 function hasOwnProperty(obj, prop) {
   return obj.hasOwnProperty(prop);
 }
-var _indexContent = async (database, documentPaths, collection) => {
-  let seedOptions = void 0;
+var _indexContent = async (database, level, documentPaths, enqueueOps, collection) => {
+  let collectionIndexDefinitions;
   if (collection) {
-    const indexDefinitions = await database.getIndexDefinitions();
-    const collectionIndexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[collection.name];
+    const indexDefinitions = await database.getIndexDefinitions(level);
+    collectionIndexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[collection.name];
     if (!collectionIndexDefinitions) {
       throw new Error(`No indexDefinitions for collection ${collection.name}`);
     }
-    const numIndexes = Object.keys(collectionIndexDefinitions).length;
-    if (numIndexes > 20) {
-      throw new Error(`A maximum of 20 indexes are allowed per field. Currently collection ${collection.name} has ${numIndexes} indexes. Add 'indexed: false' to exclude a field from indexing.`);
-    }
-    seedOptions = {
-      collection: collection.name,
-      indexDefinitions: collectionIndexDefinitions
-    };
   }
   await sequential(documentPaths, async (filepath) => {
     try {
@@ -4227,9 +4811,16 @@ var _indexContent = async (database, documentPaths, collection) => {
         frontmatterDelimiters: collection == null ? void 0 : collection.frontmatterDelimiters,
         frontmatterFormat: collection == null ? void 0 : collection.frontmatterFormat
       });
-      if (database.store.supportsSeeding()) {
-        await database.store.seed(normalizePath(filepath), data, seedOptions);
-      }
+      const normalizedPath = normalizePath(filepath);
+      await enqueueOps([
+        ...makeIndexOpsForDocument(normalizedPath, collection == null ? void 0 : collection.name, collectionIndexDefinitions, data, "put", level),
+        {
+          type: "put",
+          key: normalizedPath,
+          value: data,
+          sublevel: level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS)
+        }
+      ]);
     } catch (error) {
       throw new TinaFetchError(`Unable to seed ${filepath}`, {
         originalError: error,
@@ -4240,29 +4831,444 @@ var _indexContent = async (database, documentPaths, collection) => {
     }
   });
 };
-var _deleteIndexContent = async (database, documentPaths, collection) => {
-  let deleteOptions = void 0;
+var _deleteIndexContent = async (database, documentPaths, enequeueOps, collection) => {
+  let collectionIndexDefinitions;
   if (collection) {
-    const indexDefinitions = await database.getIndexDefinitions();
-    const collectionIndexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[collection.name];
+    const indexDefinitions = await database.getIndexDefinitions(database.level);
+    collectionIndexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[collection.name];
     if (!collectionIndexDefinitions) {
       throw new Error(`No indexDefinitions for collection ${collection.name}`);
     }
-    deleteOptions = {
-      collection: collection.name,
-      indexDefinitions: collectionIndexDefinitions
-    };
   }
+  const rootLevel = database.level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS);
   await sequential(documentPaths, async (filepath) => {
-    database.store.delete(filepath, deleteOptions);
+    const itemKey = normalizePath(filepath);
+    try {
+      const item = await rootLevel.get(itemKey);
+      if (item) {
+        await enequeueOps([
+          ...makeIndexOpsForDocument(itemKey, collection.name, collectionIndexDefinitions, item, "del", database.level),
+          { type: "del", key: itemKey, sublevel: rootLevel }
+        ]);
+      }
+    } catch (e) {
+      if (e.code !== "LEVEL_NOT_FOUND") {
+        throw e;
+      }
+    }
   });
 };
 
+// src/level/tinaLevel.ts
+var import_many_level = __toModule(require("many-level"));
+var import_readable_stream = __toModule(require("readable-stream"));
+var import_net = __toModule(require("net"));
+var TinaLevelClient = class extends import_many_level.ManyLevelGuest {
+  constructor() {
+    super(...arguments);
+    this._connected = false;
+  }
+  openConnection() {
+    if (this._connected)
+      return;
+    const socket = (0, import_net.connect)(9e3);
+    (0, import_readable_stream.pipeline)(socket, this.createRpcStream(), socket, () => {
+      this._connected = false;
+    });
+    this._connected = true;
+  }
+};
+
+// src/database/bridge/filesystem.ts
+var import_fs_extra2 = __toModule(require("fs-extra"));
+var import_fast_glob = __toModule(require("fast-glob"));
+var import_path4 = __toModule(require("path"));
+var import_normalize_path = __toModule(require("normalize-path"));
+var FilesystemBridge = class {
+  constructor(rootPath) {
+    this.rootPath = rootPath || "";
+    this.outputPath = rootPath || "";
+  }
+  addOutputPath(outputPath) {
+    this.outputPath = outputPath;
+  }
+  async glob(pattern, extension) {
+    const basePath = import_path4.default.join(this.outputPath, ...pattern.split("/"));
+    const items = await (0, import_fast_glob.default)(import_path4.default.join(basePath, "**", `/*${extension}`).replace(/\\/g, "/"), {
+      dot: true
+    });
+    const posixRootPath = (0, import_normalize_path.default)(this.outputPath);
+    return items.map((item) => {
+      return item.replace(posixRootPath, "").replace(/^\/|\/$/g, "");
+    });
+  }
+  supportsBuilding() {
+    return true;
+  }
+  async delete(filepath) {
+    await import_fs_extra2.default.remove(import_path4.default.join(this.outputPath, filepath));
+  }
+  async get(filepath) {
+    return import_fs_extra2.default.readFileSync(import_path4.default.join(this.outputPath, filepath)).toString();
+  }
+  async putConfig(filepath, data) {
+    if (this.rootPath !== this.outputPath) {
+      await this.put(filepath, data);
+      await this.put(filepath, data, this.rootPath);
+    } else {
+      await this.put(filepath, data);
+    }
+  }
+  async put(filepath, data, basePathOverride) {
+    const basePath = basePathOverride || this.outputPath;
+    await import_fs_extra2.default.outputFileSync(import_path4.default.join(basePath, filepath), data);
+  }
+};
+var AuditFileSystemBridge = class extends FilesystemBridge {
+  async put(filepath, data) {
+    if ([
+      ".tina/__generated__/_lookup.json",
+      ".tina/__generated__/_schema.json",
+      ".tina/__generated__/_graphql.json"
+    ].includes(filepath)) {
+      return super.put(filepath, data);
+    }
+    return;
+  }
+};
+
+// src/database/bridge/isomorphic.ts
+var import_isomorphic_git = __toModule(require("isomorphic-git"));
+var import_fs_extra3 = __toModule(require("fs-extra"));
+var import_glob_parent = __toModule(require("glob-parent"));
+var import_normalize_path2 = __toModule(require("normalize-path"));
+var import_graphql6 = __toModule(require("graphql"));
+var import_path5 = __toModule(require("path"));
+var flat = typeof Array.prototype.flat === "undefined" ? (entries) => entries.reduce((acc, x) => acc.concat(x), []) : (entries) => entries.flat();
+var toUint8Array = (buf) => {
+  const ab = new ArrayBuffer(buf.length);
+  const view = new Uint8Array(ab);
+  for (let i = 0; i < buf.length; ++i) {
+    view[i] = buf[i];
+  }
+  return view;
+};
+var IsomorphicBridge = class {
+  constructor(rootPath, {
+    gitRoot,
+    author,
+    committer,
+    fsModule = import_fs_extra3.default,
+    commitMessage = "Update from GraphQL client",
+    ref,
+    onPut,
+    onDelete
+  }) {
+    this.cache = {};
+    this.rootPath = rootPath;
+    this.gitRoot = gitRoot;
+    this.relativePath = rootPath.slice(this.gitRoot.length).replace(/\\/g, "/");
+    if (this.relativePath.startsWith("/")) {
+      this.relativePath = this.relativePath.slice(1);
+    }
+    this.fsModule = fsModule;
+    this.author = author;
+    this.committer = committer || author;
+    this.isomorphicConfig = {
+      dir: (0, import_normalize_path2.default)(this.gitRoot),
+      fs: this.fsModule
+    };
+    this.ref = ref;
+    this.commitMessage = commitMessage;
+    this.onPut = onPut || (() => {
+    });
+    this.onDelete = onDelete || (() => {
+    });
+  }
+  getAuthor() {
+    return __spreadProps(__spreadValues({}, this.author), {
+      timestamp: Math.round(new Date().getTime() / 1e3),
+      timezoneOffset: 0
+    });
+  }
+  getCommitter() {
+    return __spreadProps(__spreadValues({}, this.committer), {
+      timestamp: Math.round(new Date().getTime() / 1e3),
+      timezoneOffset: 0
+    });
+  }
+  async listEntries({
+    pattern,
+    entry,
+    path: path6,
+    results
+  }) {
+    const treeResult = await import_isomorphic_git.default.readTree(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+      oid: entry.oid,
+      cache: this.cache
+    }));
+    const children = [];
+    for (const childEntry of treeResult.tree) {
+      const childPath = path6 ? `${path6}/${childEntry.path}` : childEntry.path;
+      if (childEntry.type === "tree") {
+        children.push(childEntry);
+      } else {
+        if (childPath.startsWith(pattern)) {
+          results.push(childPath);
+        }
+      }
+    }
+    for (const childEntry of children) {
+      const childPath = path6 ? `${path6}/${childEntry.path}` : childEntry.path;
+      await this.listEntries({
+        pattern,
+        entry: childEntry,
+        path: childPath,
+        results
+      });
+    }
+  }
+  async resolvePathEntries(path6, ref) {
+    let pathParts = path6.split("/");
+    const result = await import_isomorphic_git.default.walk(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+      map: async (filepath, [head]) => {
+        if (head._fullpath === ".") {
+          return head;
+        }
+        if (path6.startsWith(filepath)) {
+          if ((0, import_path5.dirname)(path6) === (0, import_path5.dirname)(filepath)) {
+            if (path6 === filepath) {
+              return head;
+            }
+          } else {
+            return head;
+          }
+        }
+      },
+      cache: this.cache,
+      trees: [import_isomorphic_git.default.TREE({ ref })]
+    }));
+    const pathEntries = flat(result);
+    if (pathParts.indexOf(".") === -1) {
+      pathParts = [".", ...pathParts];
+    }
+    while (pathParts.length > pathEntries.length) {
+      pathEntries.push(null);
+    }
+    return { pathParts, pathEntries };
+  }
+  async updateTreeHierarchy(existingOid, updatedOid, path6, type, pathEntries, pathParts) {
+    const lastIdx = pathEntries.length - 1;
+    const parentEntry = pathEntries[lastIdx];
+    const parentPath = pathParts[lastIdx];
+    let parentOid;
+    let tree;
+    const mode = type === "blob" ? "100644" : "040000";
+    if (parentEntry) {
+      parentOid = await parentEntry.oid();
+      const treeResult = await import_isomorphic_git.default.readTree(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+        oid: parentOid,
+        cache: this.cache
+      }));
+      tree = existingOid ? treeResult.tree.map((entry) => {
+        if (entry.path === path6) {
+          entry.oid = updatedOid;
+        }
+        return entry;
+      }) : [
+        ...treeResult.tree,
+        {
+          oid: updatedOid,
+          type,
+          path: path6,
+          mode
+        }
+      ];
+    } else {
+      tree = [
+        {
+          oid: updatedOid,
+          type,
+          path: path6,
+          mode
+        }
+      ];
+    }
+    const updatedParentOid = await import_isomorphic_git.default.writeTree(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+      tree
+    }));
+    if (lastIdx === 0) {
+      return updatedParentOid;
+    } else {
+      return await this.updateTreeHierarchy(parentOid, updatedParentOid, parentPath, "tree", pathEntries.slice(0, lastIdx), pathParts.slice(0, lastIdx));
+    }
+  }
+  async commitTree(treeSha, ref) {
+    const commitSha = await import_isomorphic_git.default.writeCommit(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+      commit: {
+        tree: treeSha,
+        parent: [
+          await import_isomorphic_git.default.resolveRef(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+            ref
+          }))
+        ],
+        message: this.commitMessage,
+        author: this.getAuthor(),
+        committer: this.getCommitter()
+      }
+    }));
+    await import_isomorphic_git.default.writeRef(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+      ref,
+      value: commitSha,
+      force: true
+    }));
+  }
+  async getRef() {
+    if (this.ref) {
+      return this.ref;
+    }
+    const ref = await import_isomorphic_git.default.currentBranch(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+      fullname: true
+    }));
+    if (!ref) {
+      throw new import_graphql6.GraphQLError(`Unable to determine current branch from HEAD`, null, null, null, null, null, {});
+    }
+    this.ref = ref;
+    return ref;
+  }
+  async glob(pattern, extension) {
+    const ref = await this.getRef();
+    const parent = (0, import_glob_parent.default)(this.qualifyPath(pattern));
+    const { pathParts, pathEntries } = await this.resolvePathEntries(parent, ref);
+    const leafEntry = pathEntries[pathEntries.length - 1];
+    const entryPath = pathParts[pathParts.length - 1];
+    const parentEntry = pathEntries[pathEntries.length - 2];
+    let treeEntry;
+    let parentPath;
+    if (parentEntry) {
+      const treeResult = await import_isomorphic_git.default.readTree(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+        oid: await parentEntry.oid(),
+        cache: this.cache
+      }));
+      treeEntry = treeResult.tree.find((entry) => entry.path === entryPath);
+      parentPath = pathParts.slice(1, pathParts.length).join("/");
+    } else {
+      treeEntry = {
+        type: "tree",
+        oid: await leafEntry.oid()
+      };
+      parentPath = "";
+    }
+    const results = [];
+    await this.listEntries({
+      pattern: this.qualifyPath(pattern),
+      entry: treeEntry,
+      path: parentPath,
+      results
+    });
+    return results.map((path6) => this.unqualifyPath(path6)).filter((path6) => path6.endsWith(extension));
+  }
+  supportsBuilding() {
+    return true;
+  }
+  async delete(filepath) {
+    const ref = await this.getRef();
+    const { pathParts, pathEntries } = await this.resolvePathEntries(this.qualifyPath(filepath), ref);
+    let oidToRemove;
+    let ptr = pathEntries.length - 1;
+    while (ptr >= 1) {
+      const leafEntry = pathEntries[ptr];
+      const nodePath = pathParts[ptr];
+      if (leafEntry) {
+        oidToRemove = oidToRemove || await leafEntry.oid();
+        const parentEntry = pathEntries[ptr - 1];
+        const existingOid = await parentEntry.oid();
+        const treeResult = await import_isomorphic_git.default.readTree(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+          oid: existingOid,
+          cache: this.cache
+        }));
+        const updatedTree = treeResult.tree.filter((value) => value.path !== nodePath);
+        if (updatedTree.length === 0) {
+          ptr -= 1;
+          continue;
+        }
+        const updatedTreeOid = await import_isomorphic_git.default.writeTree(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+          tree: updatedTree
+        }));
+        const updatedRootTreeOid = await this.updateTreeHierarchy(existingOid, updatedTreeOid, pathParts[ptr - 1], "tree", pathEntries.slice(0, ptr - 1), pathParts.slice(0, ptr - 1));
+        await this.commitTree(updatedRootTreeOid, ref);
+        break;
+      } else {
+        throw new import_graphql6.GraphQLError(`Unable to resolve path: ${filepath}`, null, null, null, null, null, { status: 404 });
+      }
+    }
+    if (oidToRemove) {
+      await import_isomorphic_git.default.updateIndex(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+        filepath: this.qualifyPath(filepath),
+        force: true,
+        remove: true,
+        oid: oidToRemove,
+        cache: this.cache
+      }));
+    }
+    await this.onDelete(filepath);
+  }
+  qualifyPath(filepath) {
+    return this.relativePath ? `${this.relativePath}/${filepath}` : filepath;
+  }
+  unqualifyPath(filepath) {
+    return this.relativePath ? filepath.slice(this.relativePath.length + 1) : filepath;
+  }
+  async get(filepath) {
+    const ref = await this.getRef();
+    const oid = await import_isomorphic_git.default.resolveRef(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+      ref
+    }));
+    const { blob } = await import_isomorphic_git.default.readBlob(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+      oid,
+      filepath: this.qualifyPath(filepath),
+      cache: this.cache
+    }));
+    return Buffer.from(blob).toString("utf8");
+  }
+  async putConfig(filepath, data) {
+    await this.put(filepath, data);
+  }
+  async put(filepath, data) {
+    const ref = await this.getRef();
+    const { pathParts, pathEntries } = await this.resolvePathEntries(this.qualifyPath(filepath), ref);
+    const blobUpdate = toUint8Array(Buffer.from(data));
+    let existingOid;
+    const leafEntry = pathEntries[pathEntries.length - 1];
+    const nodePath = pathParts[pathParts.length - 1];
+    if (leafEntry) {
+      existingOid = await leafEntry.oid();
+      const hash = await import_isomorphic_git.default.hashBlob({ object: blobUpdate });
+      if (hash.oid === existingOid) {
+        await this.onPut(filepath, data);
+        return;
+      }
+    }
+    const updatedOid = await import_isomorphic_git.default.writeBlob(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+      blob: blobUpdate
+    }));
+    const updatedRootSha = await this.updateTreeHierarchy(existingOid, updatedOid, nodePath, "blob", pathEntries.slice(0, pathEntries.length - 1), pathParts.slice(0, pathParts.length - 1));
+    await this.commitTree(updatedRootSha, ref);
+    await import_isomorphic_git.default.updateIndex(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+      filepath: this.qualifyPath(filepath),
+      add: true,
+      oid: updatedOid,
+      cache: this.cache
+    }));
+    await this.onPut(filepath, data);
+  }
+};
+
 // src/index.ts
 var buildSchema = async (rootPath, database, flags) => {
-  const tempConfig = import_path4.default.join(rootPath, ".tina", "__generated__", "config");
-  const config = await import_fs_extra2.default.readFileSync(import_path4.default.join(tempConfig, "schema.json")).toString();
-  await import_fs_extra2.default.remove(tempConfig);
+  const tempConfig = import_path6.default.join(rootPath, ".tina", "__generated__", "config");
+  const config = await import_fs_extra4.default.readFileSync(import_path6.default.join(tempConfig, "schema.json")).toString();
+  await import_fs_extra4.default.remove(tempConfig);
   const { graphQLSchema, tinaSchema } = await buildDotTinaFiles({
     database,
     config: JSON.parse(config),
@@ -4272,12 +5278,16 @@ var buildSchema = async (rootPath, database, flags) => {
 };
 var getASTSchema = async (database) => {
   const gqlAst = await database.getGraphQLSchemaFromBridge();
-  return (0, import_graphql6.buildASTSchema)(gqlAst);
+  return (0, import_graphql7.buildASTSchema)(gqlAst);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AuditFileSystemBridge,
+  FilesystemBridge,
+  IsomorphicBridge,
   TinaFetchError,
   TinaGraphQLError,
+  TinaLevelClient,
   TinaParseDocumentError,
   TinaQueryError,
   assertShape,