@tinacms/datalayer 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # tina-graphql
 
+## 0.2.0
+
+### Minor Changes
+
+- 4daf15b36: Updated matching logic to only return the correct extension.
+
+  This means if you are using any other files besides `.md` the format must be provided in the schema.
+
+  ```ts
+  // .tina/schema.ts
+
+  import { defineSchema } from 'tinacms'
+
+  const schema = defineSchema({
+    collections: [
+      {
+        name: 'page',
+        path: 'content/page',
+        label: 'Page',
+        // Need to provide the format if the file being used (default is `.md`)
+        format: 'mdx',
+        fields: [
+          //...
+        ],
+      },
+    ],
+  })
+  //...
+
+  export default schema
+  ```
+
+### Patch Changes
+
+- b348f8b6b: Experimental isomorphic git bridge implementation
+
 ## 0.1.1
 
 ### Patch Changes

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

@@ -19,7 +19,7 @@ import type { Bridge } from './index';
 export declare class FilesystemBridge implements Bridge {
     rootPath: string;
     constructor(rootPath: string);
-    glob(pattern: string): Promise<string[]>;
+    glob(pattern: string, extension: string): Promise<string[]>;
     supportsBuilding(): boolean;
     delete(filepath: string): Promise<void>;
     get(filepath: string): Promise<string>;

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

@@ -12,7 +12,8 @@ limitations under the License.
 */
 export interface Bridge {
     rootPath: string;
-    glob(pattern: string): Promise<string[]>;
+    glob(pattern: string, extension: string): Promise<string[]>;
+    delete(filepath: string): Promise<void>;
     get(filepath: string): Promise<string>;
     put(filepath: string, data: string): Promise<void>;
     /**

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

@@ -0,0 +1,108 @@
+/**
+ Copyright 2021 Forestry.io Holdings, Inc.
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+import { CallbackFsClient, PromiseFsClient } from 'isomorphic-git';
+import type { Bridge } from './index';
+export declare type IsomorphicGitBridgeOptions = {
+    gitRoot: string;
+    fsModule?: CallbackFsClient | PromiseFsClient;
+    commitMessage?: string;
+    author: {
+        name: string;
+        email: string;
+    };
+    committer?: {
+        name: string;
+        email: string;
+    };
+    ref?: string;
+    onPut?: (filepath: string, data: string) => Promise<void>;
+    onDelete?: (filepath: string) => Promise<void>;
+};
+/**
+ * Bridge backed by isomorphic-git
+ */
+export declare class IsomorphicBridge implements Bridge {
+    rootPath: string;
+    relativePath: string;
+    gitRoot: string;
+    fsModule: CallbackFsClient | PromiseFsClient;
+    isomorphicConfig: {
+        fs: CallbackFsClient | PromiseFsClient;
+        dir: string;
+    };
+    commitMessage: string;
+    author: {
+        name: string;
+        email: string;
+    };
+    committer: {
+        name: string;
+        email: string;
+    };
+    ref: string | undefined;
+    private readonly onPut;
+    private readonly onDelete;
+    private cache;
+    constructor(rootPath: string, { gitRoot, author, committer, fsModule, commitMessage, ref, onPut, onDelete, }: IsomorphicGitBridgeOptions);
+    private getAuthor;
+    private getCommitter;
+    /**
+     * Recursively populate paths matching `pattern` for the given `entry`
+     *
+     * @param pattern - pattern to filter paths by
+     * @param entry - TreeEntry to start building list from
+     * @param path - base path
+     * @param results
+     * @private
+     */
+    private listEntries;
+    /**
+     * For the specified path, returns an object with an array containing the parts of the path (pathParts)
+     * and an array containing the WalkerEntry objects for the path parts (pathEntries). Any null elements in the
+     * pathEntries are placeholders for non-existent entries.
+     *
+     * @param path - path being resolved
+     * @param ref - ref to resolve path entries for
+     * @private
+     */
+    private resolvePathEntries;
+    /**
+     * Updates tree entry and associated parent tree entries
+     *
+     * @param existingOid - the existing OID
+     * @param updatedOid - the updated OID
+     * @param path - the path of the entry being updated
+     * @param type - the type of the entry being updated (blob or tree)
+     * @param pathEntries - parent path entries
+     * @param pathParts - parent path parts
+     * @private
+     */
+    private updateTreeHierarchy;
+    /**
+     * Creates a commit for the specified tree and updates the specified ref to point to the commit
+     *
+     * @param treeSha - sha of the new tree
+     * @param ref - the ref that should be updated
+     * @private
+     */
+    private commitTree;
+    private getRef;
+    glob(pattern: string, extension: string): Promise<string[]>;
+    supportsBuilding(): boolean;
+    delete(filepath: string): Promise<void>;
+    private qualifyPath;
+    private unqualifyPath;
+    get(filepath: string): Promise<string>;
+    putConfig(filepath: string, data: string): Promise<void>;
+    put(filepath: string, data: string): Promise<void>;
+}

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

@@ -18,12 +18,12 @@ export declare class FilesystemStore implements Store {
     constructor({ rootPath }: {
         rootPath?: string;
     });
-    query(queryOptions: StoreQueryOptions): Promise<StoreQueryResponse>;
+    query(_queryOptions: StoreQueryOptions): Promise<StoreQueryResponse>;
     seed(): Promise<void>;
     get<T extends object>(filepath: string): Promise<T>;
     supportsSeeding(): boolean;
     supportsIndexing(): boolean;
-    glob(pattern: string, callback: any): Promise<any[]>;
+    glob(pattern: string, callback: any, extension: any): Promise<any[]>;
     put(filepath: string, data: object, options?: PutOptions): Promise<void>;
     open(): Promise<void>;
     close(): Promise<void>;

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

@@ -89,7 +89,7 @@ export declare type DeleteOptions = SeedOptions & {
     seed?: boolean;
 };
 export interface Store {
-    glob(pattern: string, hydrator?: (fullPath: string) => Promise<object>): Promise<string[]>;
+    glob(pattern: string, hydrator?: (fullPath: string) => Promise<object>, extension?: string): Promise<string[]>;
     get<T extends object>(filepath: string): Promise<T>;
     delete(filepath: string, options?: DeleteOptions): Promise<void>;
     clear(): void;

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

@@ -1,15 +1,15 @@
 /**
-Copyright 2021 Forestry.io Holdings, Inc.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
+ Copyright 2021 Forestry.io Holdings, Inc.
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
 import type { StoreQueryOptions, StoreQueryResponse, PutOptions, DeleteOptions, SeedOptions, Store } from './index';
 import { LevelDB } from 'level';
 export declare class LevelStore implements Store {

package/dist/index.d.ts

@@ -11,6 +11,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 export { FilesystemBridge, AuditFileSystemBridge, } from './database/bridge/filesystem';
+export { IsomorphicBridge } from './database/bridge/isomorphic';
 export { FilesystemStore, AuditFilesystemStore, } from './database/store/filesystem';
 export { LevelStore } from './database/store/level';
 export { coerceFilterChainOperands, DEFAULT_COLLECTION_SORT_KEY, DEFAULT_NUMERIC_LPAD, INDEX_KEY_FIELD_SEPARATOR, makeFilter, makeFilterChain, makeFilterSuffixes, makeKeyForField, makeStringEscaper, OP, } from './database/store';

package/dist/index.js

@@ -60,6 +60,7 @@ __export(exports, {
   FilesystemBridge: () => FilesystemBridge,
   FilesystemStore: () => FilesystemStore,
   INDEX_KEY_FIELD_SEPARATOR: () => INDEX_KEY_FIELD_SEPARATOR,
+  IsomorphicBridge: () => IsomorphicBridge,
   LevelStore: () => LevelStore,
   OP: () => OP,
   atob: () => atob,
@@ -81,9 +82,9 @@ var FilesystemBridge = class {
   constructor(rootPath) {
     this.rootPath = rootPath || "";
   }
-  async glob(pattern) {
+  async glob(pattern, extension) {
     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, "/"), {
+    const items = await (0, import_fast_glob.default)(import_path.default.join(basePath, "**", `/*${extension}`).replace(/\\/g, "/"), {
       dot: true
     });
     const posixRootPath = (0, import_normalize_path.default)(this.rootPath);
@@ -113,18 +114,335 @@ var AuditFileSystemBridge = class extends FilesystemBridge {
   }
 };
 
-// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/database/store/filesystem.ts
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/database/bridge/isomorphic.ts
+var import_isomorphic_git = __toModule(require("isomorphic-git"));
 var import_fs_extra2 = __toModule(require("fs-extra"));
+var import_glob_parent = __toModule(require("glob-parent"));
+var import_normalize_path2 = __toModule(require("normalize-path"));
+var import_graphql = __toModule(require("graphql"));
+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_extra2.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: path4,
+    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 = path4 ? `${path4}/${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 = path4 ? `${path4}/${childEntry.path}` : childEntry.path;
+      await this.listEntries({
+        pattern,
+        entry: childEntry,
+        path: childPath,
+        results
+      });
+    }
+  }
+  async resolvePathEntries(path4, ref) {
+    let pathParts = path4.split("/");
+    const result = await import_isomorphic_git.default.walk(__spreadProps(__spreadValues({}, this.isomorphicConfig), {
+      map: async (filepath, [head]) => {
+        if (head._fullpath === "." || path4.startsWith(filepath)) {
+          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, path4, 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 === path4) {
+          entry.oid = updatedOid;
+        }
+        return entry;
+      }) : [
+        ...treeResult.tree,
+        {
+          oid: updatedOid,
+          type,
+          path: path4,
+          mode
+        }
+      ];
+    } else {
+      tree = [
+        {
+          oid: updatedOid,
+          type,
+          path: path4,
+          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_graphql.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((path4) => this.unqualifyPath(path4)).filter((path4) => path4.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_graphql.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);
+  }
+};
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/database/store/filesystem.ts
+var import_fs_extra3 = __toModule(require("fs-extra"));
 var import_fast_glob2 = __toModule(require("fast-glob"));
 var import_path2 = __toModule(require("path"));
-var import_normalize_path2 = __toModule(require("normalize-path"));
+var import_normalize_path3 = __toModule(require("normalize-path"));
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/database/util.ts
 var import_gray_matter = __toModule(require("gray-matter"));
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/datalayer/src/util.ts
 var yup = __toModule(require("yup"));
-var import_graphql = __toModule(require("graphql"));
+var import_graphql2 = __toModule(require("graphql"));
 var sequential = async (items, callback) => {
   const accum = [];
   if (!items) {
@@ -149,7 +467,7 @@ function assertShape(value, yupSchema, errorMessage) {
     shape.validateSync(value);
   } catch (e) {
     const message = errorMessage || `Failed to assertShape - ${e.message}`;
-    throw new import_graphql.GraphQLError(message, null, null, null, null, null, {
+    throw new import_graphql2.GraphQLError(message, null, null, null, null, null, {
       stack: e.stack
     });
   }
@@ -225,14 +543,14 @@ var FilesystemStore = class {
   constructor({ rootPath }) {
     this.rootPath = rootPath || "";
   }
-  async query(queryOptions) {
+  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_path2.default.join(this.rootPath, filepath)).toString(), import_path2.default.extname(filepath), (yup2) => yup2.object());
+    return parseFile(await import_fs_extra3.default.readFileSync(import_path2.default.join(this.rootPath, filepath)).toString(), import_path2.default.extname(filepath), (yup2) => yup2.object());
   }
   supportsSeeding() {
     return false;
@@ -240,12 +558,12 @@ var FilesystemStore = class {
   supportsIndexing() {
     return false;
   }
-  async glob(pattern, callback) {
+  async glob(pattern, callback, extension) {
     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, "/"), {
+    const itemsRaw = await (0, import_fast_glob2.default)(import_path2.default.join(basePath, "**", `/*${extension}`).replace(/\\/g, "/"), {
       dot: true
     });
-    const posixRootPath = (0, import_normalize_path2.default)(this.rootPath);
+    const posixRootPath = (0, import_normalize_path3.default)(this.rootPath);
     const items = itemsRaw.map((item) => {
       return item.replace(posixRootPath, "").replace(/^\/|\/$/g, "");
     });
@@ -258,14 +576,14 @@ var FilesystemStore = class {
     }
   }
   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));
+    await import_fs_extra3.default.outputFileSync(import_path2.default.join(this.rootPath, filepath), stringifyFile(data, import_path2.default.extname(filepath), options.keepTemplateKey));
   }
   async open() {
   }
   async close() {
   }
   async delete(filepath) {
-    await import_fs_extra2.default.remove(import_path2.default.join(this.rootPath, filepath));
+    await import_fs_extra3.default.remove(import_path2.default.join(this.rootPath, filepath));
   }
 };
 var AuditFilesystemStore = class extends FilesystemStore {
@@ -825,6 +1143,7 @@ var LevelStore = class {
   FilesystemBridge,
   FilesystemStore,
   INDEX_KEY_FIELD_SEPARATOR,
+  IsomorphicBridge,
   LevelStore,
   OP,
   atob,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinacms/datalayer",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "files": [
@@ -29,8 +29,10 @@
     "encoding-down": "^7.1.0",
     "fast-glob": "^3.2.5",
     "fs-extra": "^9.0.1",
+    "glob-parent": "^6.0.2",
     "graphql": "^15.3.0",
     "gray-matter": "^4.0.2",
+    "isomorphic-git": "^1.10.3",
     "js-yaml": "^3.14.0",
     "jsonpath-plus": "^6.0.1",
     "level": "^7.0.1",
@@ -50,7 +52,7 @@
     "directory": "packages/@tinacms/datalayer"
   },
   "devDependencies": {
-    "@tinacms/scripts": "0.50.7",
+    "@tinacms/scripts": "0.50.9",
     "@types/fs-extra": "^9.0.2",
     "@types/jest": "^27.4.1",
     "@types/js-yaml": "^3.12.5",