@ocfl/ocfl 0.2.2 → 0.4.0

package/lib/object.js

@@ -3,207 +3,262 @@
 
 const path = require('path');
 const validation = require('./validation.js');
-const { Enum } = require('./enum.js');
-const { OcflObjectInventory, OcflObjectInventoryMut } = require('./inventory.js');
+const { enumeration } = require('./enum.js');
+const { OcflObjectInventory, OcflObjectInventoryMut, VersionNumber } = require('./inventory.js');
 const { OcflDigest } = require('./digest.js');
-const { createTransactionProxy, OcflObjectTransaction, OcflObjectTransactionImpl } = require('./transaction.js');
+const { OcflObjectTransaction, OcflObjectTransactionImpl } = require('./transaction.js');
 const { OcflStore } = require('./store.js');
 const { OcflExtension } = require('./extension.js');
 const { NotImplementedError } = require('./error.js');
-const { parallelize, dataSourceAsIterable, isDirEmpty, findNamasteVersion } = require('./utils');
+const { parallelize, isDirEmpty, findNamasteVersion } = require('./utils');
+const { OcflObjectFile } = require('./file.js');
 const { OCFL_VERSION, OCFL_VERSIONS, INVENTORY_NAME, NAMASTE_PREFIX_OBJECT, NAMASTE_T } = require('./constants').OcflConstants;
 
-class UPDATE_MODE extends Enum {
-  /** Merge all changes with the last version during update */
-  static MERGE = new this();
-  /** New version will assume that all existing files are removed first before adding new ones */
-  static REPLACE = new this();
-};
+const UPDATE_MODES = /** @type { const } */(['MERGE', 'REPLACE']);
+const UPDATE_MODE = enumeration(UPDATE_MODES);
 const DIGEST = OcflDigest.CONTENT;
 
 /**
- * @typedef {Object} OcflObjectConfig
- * @property {string} root - Absolute path to the ocfl object root.
- * @property {string} [workspace] - Absolute path to object workspace directory.
- * @property {('sha256' | 'sha512')} [digestAlgorithm] - Digest algorithm for content-addressing, must use either sha512 or sha256.
- * @property {string} [id] - Identifier for the object.  Only be used in a newly created object.
- * @property {string} [contentDirectory='content'] - Content directory name. Only applies to a newly created object.
- * @property {string} [ocflVersion=c.OCFL_VERSION] - Ocfl version. Only applies to a newly created object.
- * @property {OcflExtension[]} [extensions] - Reference to existing extensions defined outside of the object, such as in the storage root.
- */
-/**
- * @typedef {UPDATE_MODE | ('MERGE' | 'REPLACE') } ObjectUpdateMode
- * 
- * @typedef {Object} FileRef
- * @property {string} [contentPath] - Actual path to the file location relative to the ocfl object root.
- * @property {string} [logicalPath] - A path that represents a file’s location in the logical state of an object.
- * @property {string} [digest] - An algorithmic characterization of the contents of a file conforming to a standard digest algorithm.
- * @property {string} [version] - Version of the OCFL object.
- * @property {string} [lastModified] - Last modified date of the file.
- * @property {string} [size] - Size of the file in bytes.
+ * @typedef {(typeof UPDATE_MODES)[number]} UpdateModeStr
+ * @typedef { InstanceType<typeof UPDATE_MODE> | UpdateModeStr} UpdateMode
+ * @typedef {string} LogicalPath
  * @typedef {{logicalPath: string, version?: string}} FileRefLogical
- * @typedef {{digest: string}} FileRefDigest
- * @typedef {{contentPath: string}} FileRefContent
+ * @typedef {{digest: string, version?: string}} FileRefDigest
+ * @typedef {{contentPath: string, version?: string}} FileRefContent
+ * @typedef {import('./types').Inventory} Inventory
+ * @typedef {import('./types').OcflVersion} OcflVersion
+ * @typedef {import('./types').OcflObjectConfig} OcflObjectConfig
+ * 
  */
 
 /**
- * Represent a file in an OCFL object
+ * A class representing an OCFL Object allowing to read and write the content of an OCFL Object in the underlying store.
  */
-class OcflObjectFile {
-  #ocflObject;
-  #lastModified;
-  #size;
-
-  /**
-   * 
-   * @param {OcflObjectImpl} ocflObject 
-   * @param {FileRef} fileRef 
-   */
-  constructor(ocflObject, fileRef) {
-    this.#ocflObject = ocflObject;
-    // for (const key in ['logicalPath', 'version', 'digest', 'contentPath']) {
-    //   if (fileRef[key]) this[key] = fileRef[key];
-    // }
-    if (fileRef.logicalPath) this.logicalPath = fileRef.logicalPath;
-    if (fileRef.contentPath) this.contentPath = fileRef.contentPath;
-    if (fileRef.digest) this.digest = fileRef.digest;
-    if (fileRef.version) this.version = fileRef.version;
-    if (fileRef.lastModified != null) this.#lastModified = fileRef.lastModified;
-    if (fileRef.size != null) this.#size = fileRef.size;
-  }
-
-  /**
-   * Resolve contentPath given either the `logicalPath` and `version`, `digest`, or `contentPath`.
-   */
-  async #resolveContentPath() {
-    let contentPath = this.contentPath;
-    if (!contentPath) {
-      let inv = await this.#ocflObject.getInventory();
-      if (!inv) throw new Error(`OCFL Object "${this.#ocflObject.id}" does not exist`);
-      let version = !this.version || this.version === 'latest' ? inv.head : this.version;
-      let digest = this.digest || inv.getDigest(this.logicalPath, version);
-      contentPath = inv.getContentPath(digest);
-      if (!contentPath) throw new Error(`Cannot find content "${this.toString()}" in the OCFL Object "${this.#ocflObject.id}" version "${this.version || 'latest'}"`);
-    }
-    return contentPath;
-  }
+class OcflObject {
 
-  /**
-   * Returns the last modified time of the file, in millisecond since the UNIX epoch (January 1st, 1970 at Midnight).
-   */
-  get lastModified() { return this.#lastModified  }
-  
-  /**
-   * Returns the file size in bytes.
+  /** @type {OcflVersion} */
+  #ocflVersion;
+  /** @type {string} */
+  #root;
+  /** @type {string} */
+  #workspace;
+  /** @type {string} */
+  #id;
+  /** @type {('sha256' | 'sha512')} */
+  #digestAlgorithm;
+  /** @type {OcflExtension[]} */
+  #extensions;
+  /** @type {OcflStore} */
+  #store;
+  /** 
+   * A default list of digest algorithms to be calculated for each file in this object and added to the fixity block.
+   * @type {string[]} 
    */
-  get size() { return this.#size }
-
-  toString() {
-    let props = [];
-    for (const key in ['logicalPath', 'version', 'digest', 'contentPath']) {
-      if (this[key]) props.push(key + ": '" + this[key] + "'");
-    }
-    return `{ ${props.join(', ')} }`;
-  }
-
-  /**
-   * Get the file content as a buffer
-   * @param {*} [options] Options to be passed to underlying data store specific implementation
+  fixityAlgorithms;
 
-   * @return {Promise<Buffer>}
-   */
-  async buffer(options) {
-    return this.#ocflObject.readFile(await this.#resolveContentPath(), options);
-  }
   /**
-   * @deprecated
+   * Create a new OCFL Object
+   * @param {OcflObjectConfig} config
+   * @param {OcflStore} store
    */
-  async asBuffer(options) {
-    return this.buffer(options);
+  constructor(config, store) {
+    if (!store) throw new TypeError('[OcflObject] store is required.');
+    this.#store = store;
+    if (!config.root) throw new TypeError('[OcflObject] config.root is required.');
+    if (config.root === config.workspace) throw new Error('[OcflObject] config.root and config.workspace must be different.');
+    this.#root = path.resolve(config.root);
+    this.#ocflVersion = config.ocflVersion || /** @type {OcflVersion} */(OCFL_VERSION);
+    //this.contentVersion = null; // No content yet
+    this.#id = config.id;
+    this.#extensions = config.extensions;
+    //this.fixityDigest = config.fixityDigest ?? this.digestAlgorithm;
+    this.digestAlgorithm = config.digestAlgorithm || 'sha512';
+    this.#workspace = config.workspace ? path.resolve(config.workspace) : undefined;
+    this.contentDirectory = config.contentDirectory ?? 'content';
+    /** @type Object.<string, OcflObjectInventory> */
+    this._inventory = {};
+    this.fixityAlgorithms = config.fixityAlgorithms;
   }
 
-  /**
-   * Get the file content as a string
-   * @param {BufferEncoding} [encoding='utf8'] String encoding, default to utf8
-   * @return {Promise<string>}
-   */
-  async text(encoding = 'utf8') {
+  /** the digest algorithm used to identify files within the OCFL object */
+  get digestAlgorithm() { return this.#digestAlgorithm; }
+  set digestAlgorithm(algorithm) {
+    this.#digestAlgorithm = algorithm;
     // @ts-ignore
-    return this.buffer(encoding);
-  }
-  /**
-   * @deprecated
-   */
-  async asString(encoding = 'utf8') {
-    // @ts-ignore
-    return this.text(encoding);
+    this.#digestAlgorithm = enumeration.of(DIGEST, algorithm || 'sha512')?.name;
+    if (!this.#digestAlgorithm) throw new Error('Invalid digest algorithm. Must be one of `sha256` or `sha512`.');
   }
 
-  /**
-   * Get the file content as a NodeJS stream
-   * @param {*} [options] Options to be passed to underlying data store specific implementation
-   * @return {Promise<NodeJS.ReadableStream>}
-   * @deprecated
-   */
-  async asStream(options) {
-    return this.#ocflObject.createReadStream(await this.#resolveContentPath(), options);
-  }
+  /** 
+  * Identifier of the OCFL Object
+  * @return {string} 
+  */
+  get id() { return this.inventory?.id || this.#id; }
 
-  /**
-   * Get the file content as a ES Streams standard ReadableStream
-   * @param {*} [options] Options to be passed to underlying data store specific implementation
-   * @return {Promise<ReadableStream>}
-   */
-  async stream(options) {
-    return this.#ocflObject.createReadable(await this.#resolveContentPath(), options);
+  /** 
+  * Latest version number of the OCFL Object
+  * @return {VersionNumber} 
+  */
+  get headVersion() {
+    const head = this.inventory?.head;
+    if (head) return VersionNumber.fromString(head);
   }
-}
-
-
-/**
- * Interface class representing OCFL Object
- * @interface
- */
-class OcflObject {
 
   /** 
-   * Identifier of the OCFL Object
-   * @return {string} 
-   */
-  get id() { throw new NotImplementedError(); }
+  * All available version numbers in the OCFL Object
+  * @return {VersionNumber[]} 
+  */
+  get versions() {
+    return Object.keys(this.inventory?.versions || {}).map(v => VersionNumber.fromString(v));
+  }
 
   /** 
   * The absolute path to the root of this OCFL Object
   * @return {string} 
   */
-  get root() { throw new NotImplementedError(); }
+  get root() { return this.#root; }
 
   /** 
   * The absolute path to the temporary workspace of this OCFL Object
   * @return {string} 
   */
-  get workspace() { throw new NotImplementedError(); }
+  get workspace() { return this.#workspace; }
 
-  toString() { return `OcflObject { root: ${this.root}, id: ${this.id} }`; }
+  /** The raw OCFL version number the object adheres to , eg 1.0, 1.1) */
+  get ocflVersion() { return this.#ocflVersion; }
 
-  toJSON() { return { root: this.root, id: this.id }; }
+  /**
+   * Create a new backend-specific update transaction
+   * @param {OcflObjectInventoryMut} inventory
+   * @return {Promise<OcflObjectTransaction>}
+   */
+  async #createTransaction(inventory) {
+    await this._validateObjectPath();
+    if (!this.workspace) await this._ensureNamaste();
+    let workspacePath = this.workspace || this.root;
+    return OcflObjectTransactionImpl.create(this, this.#store, inventory, workspacePath);
+  }
+
+  async _ensureNamaste() {
+    let prefix = NAMASTE_PREFIX_OBJECT;
+    let nv = await findNamasteVersion(this.#store, prefix, this.root);
+    if (nv === '') throw validation.createError(6, this.root);
+    if (nv) {
+      if (!this.ocflVersion) this.#ocflVersion = /** @type {OcflVersion} */(nv);
+      return;
+    }
+    // namaste not found, check if object root is not empty
+    let files;
+    try {
+      files = await this.#store.readdir(this.root);
+    } catch (error) {
+    }
+    if (files && files.length > 0) throw new Error('Cannot create an OCFL Object in a non-empty directory');
+    //create the namaste file
+    let filePath = path.join(this.root, NAMASTE_T + prefix + this.ocflVersion);
+    await this.#store.writeFile(filePath, prefix + this.ocflVersion + '\n', 'utf8');
+  }
+
+  /**
+   * Read and parse the inventory.json file
+   * @param {string} [version] - Full name of the version, eg: v1, v2, v3 
+   * @returns {Promise<OcflObjectInventory>}
+   */
+  async _readInventory(version = 'latest') {
+    let invPath = version === 'latest' ? INVENTORY_NAME : path.join(version, INVENTORY_NAME);
+    let datastr;
+    try {
+      datastr = /** @type string */(await this.readFile(invPath, 'utf8'));
+    } catch (err) {
+      if (err.code !== 'ENOENT') throw err;
+      //inventory does not exist yet
+      return;
+    }
+    let data = /** @type Inventory */(JSON.parse(datastr));
+    let [digest, actualDigest] = /** @type [string,string] */ (await Promise.all([
+      this.readFile(invPath + '.' + data.digestAlgorithm, 'utf8'),
+      OcflDigest.digest(data.digestAlgorithm, datastr)
+    ]));
+    digest = digest.match(/[^\s]+/)?.[0];
+    if (digest !== actualDigest) throw new Error(`Inventory file ${this.root}/${invPath} digest mismatch: recorded=${digest} actual=${actualDigest}`);
+    //return new OcflObjectInventory({ data, digest });
+    return new OcflObjectInventory(data);
+  }
+
+  /**
+   * Set the latest version of inventory in the cache
+   * @param {*} inventory 
+   * @param {*} version 
+   */
+  _setInventory(inventory, version = 'latest') {
+    //this._inventory['latest'] = this._inventory[inventory.head] = inventory;
+    this._inventory[version] = inventory;
+    if (version === 'latest') this._inventory[inventory.head] = inventory;
+  }
+
+  // all the parent directories cannot be an ocfl object
+  async _validateObjectPath() {
+    var p = this.root;
+    while (p !== '.' && p !== '/') {
+      p = path.dirname(p);
+      let nv = await findNamasteVersion(this.#store, NAMASTE_PREFIX_OBJECT, p);
+      if (nv) throw new Error(`Object root cannot be nested under another object ${p}`);
+    }
+  }
 
   /**
    * If a cache exists, return the cached inventory. Otherwise read it from the storage and cache it.
+   * If the inventory file does not exist, eg in a newly created object, returns undefined. 
    * @param {string} [version] - Full name of the version, eg: v1, v2, v3  
    * @returns {Promise<OcflObjectInventory>}
    */
-  async getInventory(version = 'latest') { throw new NotImplementedError(); }
+  async getInventory(version = 'latest') {
+    if (!this._inventory[version]) {
+      let inv = await this._readInventory(version);
+      if (inv) this._setInventory(inv, version);
+    }
+    return this._inventory[version];
+  }
+
+  _baseInventory() {
+    return {
+      id: this.id,
+      digestAlgorithm: this.digestAlgorithm || 'sha512',
+      type: /** @type {Inventory["type"]} */(`https://ocfl.io/${this.ocflVersion}/spec/#inventory`),
+      contentDirectory: this.contentDirectory || 'content'
+    };
+  }
 
   /**
    * Update the content files or directories as one transaction and commit the changes as a new version.
+   * After obtaining the OcflObjectTransaction instance, make sure to either call the
+   * {@link OcflObjectTransaction#commit} or {@link OcflObjectTransaction#rollback} method to complete the transaction.
    * If callback function `cb` is provided, all update operations can be done in the callback function
    * and all changes are automatically commited at the end of the function.
-   * @param {function(OcflObjectTransaction):*} [updater]
-   * @param {ObjectUpdateMode} [mode=UPDATE_MODE.MERGE]
+   * @param {function(OcflObjectTransaction):Promise<*>} [updater]
+   * @param {UpdateMode} [mode_]
    * @return {Promise<?OcflObjectTransaction>}
    */
-  async update(updater, mode) { throw new NotImplementedError(); }
+  async update(updater, mode_ = UPDATE_MODE.MERGE) {
+    const mode = enumeration.of(UPDATE_MODE, mode_);
+    if (!mode) throw new TypeError(`Invalid mode '${mode.toString()}'`);
+    const inv = await this.getInventory() ?? this._baseInventory();
+    const newInv = await OcflObjectInventory.newVersion(inv, mode === UPDATE_MODE.REPLACE);
+    const t = await this.#createTransaction(newInv);
+    if (typeof updater === 'function') {
+      try {
+        await updater(t);
+      } catch (error) {
+        // console.log(error);
+        await t.rollback();
+        throw error;
+      }
+      await t.commit();
+      return;
+    }
+    return t;
+  }
+
 
   /**
    * Import one or more content files or directories to the object 
@@ -211,7 +266,7 @@ class OcflObject {
    * Use this method to simplify copying all contents of a directory 
    * in local filesystem to the OCFL Object content directory
    * @param {string|string[]|string[][]} content - The source path(s) or an array of a tuple [source, logical path]
-   * @param {ObjectUpdateMode} [mode=UPDATE_MODE.MERGE] - Update mode.
+   * @param {UpdateMode} [mode=UPDATE_MODE.MERGE] - Update mode.
    */
   async import(content, mode = UPDATE_MODE.MERGE) {
     //let entries = /**@type {string[][]}*/(content);
@@ -243,44 +298,17 @@ class OcflObject {
     await this.import(sourceDir, mode);
   }
 
-  async load() { throw new NotImplementedError(); }
-
-  /**
-   * Iterate through the content files contained in the specified version. 
-   * Returns an Iterator that contains FileRef which consists of logical path, content path, and digest, in no particular order.
-   * The iterator is implemented as a generator.
-   * @param {string} [version]
-   * @return {Promise<Generator<OcflObjectFile, void, unknown>>}
-   */
-  async files(version) { throw new Error('Not Implemented'); }
-
-  /**
-   * Get a file by its logical path and version. If version is omitted, it defaults to the last version.
-   * @callback GetFileByLogical 
-   * @param {string} logicalPath Logical path of the file, eg: 'test'
-   * @param {string} [version='latest'] The object version name, eg: 'v1', 'v2'. Default to 'latest'
-   * @returns {OcflObjectFile}
-   */
-  /**
-   * Get a file by either the [logical path and version], digest, or content path.
-   * @callback GetFileByOpt
-   * @param { FileRefLogical | FileRefDigest | FileRefContent } opt A choice of logical path (eg: 'test') and version (eg: 'v1'), 
-   * digest of the file content, or content path (eg: 'v1/content/test')
-   * @returns {OcflObjectFile}
-   */
-  /**
-   * Retrieve the content of a file either as string, buffer, or stream.
-   * @type { GetFileByLogical & GetFileByOpt }
-   */
-  // @ts-ignore
-  getFile = function (opt, version) { };
-
   /**
    * Count the number of files contained in this object
    * @param {string} [version]
    */
   async count(version) {
-    return [...await this.files(version)].length;
+    let inv = await this.getInventory();
+    return [...inv.files(version)].length;
+  }
+
+  async createReadable(filePath, options) {
+    return this.#store.createReadable(path.join(this.root, filePath), options);
   }
 
   /**
@@ -289,172 +317,157 @@ class OcflObject {
    * The existing directory may or may not be a valid OCFL Object.
    * @return {Promise<boolean>}
    */
-  async exists() { throw new Error('Not Implemented'); }
-
-  //async inventory(version = 'latest') { }
-
-}
-
-
-/**
- * Abstract class implementing {@link OcflObject}. 
- * This class provides common functionalities for the subclasses and 
- * at the same provide encapsulation emulating private and protected methods.
- * @implements {OcflObject}
- */
-class OcflObjectImpl extends OcflObject {
-
-  /** @type {string} */
-  #root;
-  /** @type {string} */
-  #workspace;
-  /** @type {string} */
-  #id;
-  /** @type {OcflExtension[]} */
-  #extensions;
-  /** @type {OcflStore} */
-  #store;
+  async exists() {
+    return !(await isDirEmpty(this.#store, this.root));
+  }
 
   /**
-   * Create a new OCFL Object
-   * @param {OcflObjectConfig} config
-   * @param {OcflStore} store
+   * Copy all content of this Object to a directory in local filesystem
+   * @param {string} targetDir 
+   * @param {string} version 
    */
-  constructor(config, store) {
-    super();
-    if (!store) throw new TypeError('[OcflObject] store is required.');
-    this.#store = store;
-    if (!config.root) throw new TypeError('[OcflObject] config.root is required.');
-    if (config.root === config.workspace) throw new Error('[OcflObject] config.root and config.workspace must be different.');
-    this.#root = path.resolve(config.root);
-    this.ocflVersion = config.ocflVersion || OCFL_VERSION;
-    //this.contentVersion = null; // No content yet
-    this.#id = config.id;
-    this.#extensions = config.extensions;
-    this.digestAlgorithm = DIGEST.of(config.digestAlgorithm || 'sha512');
-    if (!this.digestAlgorithm) throw new Error('Invalid digest algorithm. Must be one of `sha256` or `sha512`.');
-    //this.fixityDigest = config.fixityDigest ?? this.digestAlgorithm;
-    this.#workspace = config.workspace ? path.resolve(config.workspace) : undefined;
-    this.contentDirectory = config.contentDirectory ?? 'content';
-    /** @type Object.<string, OcflObjectInventory> */
-    this._inventory = {};
-  }
-  get id() { return this._inventory?.latest?.id || this.#id; }
-  get root() { return this.#root; }
-  get workspace() { return this.#workspace; }
+  async export(targetDir, version) { throw new Error('Not Implemented'); }
 
-  async getInventory(version = 'latest') {
-    if (!this._inventory[version]) {
-      let inv = await this._readInventory(version);
-      if (inv) this._inventory[version] = inv;
+  /**
+   * Iterate through the content files contained in the specified version. 
+   * Returns an Iterator that contains FileRef which consists of logical path, content path, and digest, in no particular order.
+   * The iterator is implemented as a generator.
+   * @param {string} [version]
+   * @return {Promise<Generator<OcflObjectFile, void, unknown>>}
+   */
+  async files(version) {
+    let inv = await this.getInventory();
+    let o = this;
+    function* files() {
+      for (const f of inv.files(version)) {
+        yield new OcflObjectFile(o, f);
+      }
     }
-    return this._inventory[version];
+    return files();
   }
 
-  _setInventory(inventory) {
-    this._inventory['latest'] = this._inventory[inventory.head] = inventory;
-  }
+  /**
+   * Return a file representation by the content path and version,
+   * @param { string } contentPath 
+   * @param { string } [version='latest']
+   */
+  async fileByContentPath(contentPath, version) {
+    const inv = await this.getInventory();
+    const fr = inv?.getFileByContentPath(contentPath, version);
+    if (fr) return new OcflObjectFile(this, fr);
+  };
 
   /**
-   * Read and parse the inventory.json file
-   * @param {string} [version] - Full name of the version, eg: v1, v2, v3 
-   * @returns {Promise<OcflObjectInventory>}
+   * Return a file representation by the digest and version,
+   * @param { string } digest 
+   * @param { string } [version='latest']
    */
-  async _readInventory(version = 'latest') {
-    let invPath = version === 'latest' ? INVENTORY_NAME : path.join(version, INVENTORY_NAME);
-    let datastr;
-    try {
-      datastr = /** @type string */(await this.readFile(invPath, 'utf8'));
-    } catch (err) {
-      if (err.code !== 'ENOENT') throw err;
-      //inventory does not exist yet
-      return;
-    }
-    let data = /** @type Inventory */(JSON.parse(datastr));
-    let [digest, actualDigest] = /** @type [string,string] */ (await Promise.all([
-      this.readFile(invPath + '.' + data.digestAlgorithm, 'utf8'),
-      OcflDigest.digestAsync(data.digestAlgorithm, datastr)
-    ]));
-    digest = digest.match(/[^\s]+/)?.[0];
-    if (digest !== actualDigest) throw new Error(`Inventory file ${this.root}/${invPath} digest mismatch: recorded=${digest} actual=${actualDigest}`);
-    //return new OcflObjectInventory({ data, digest });
-    return new OcflObjectInventory(data);
-  }
+  async fileByDigest(digest, version) {
+    const inv = await this.getInventory();
+    const fr = inv?.getFileByDigest(digest, version);
+    if (fr) return new OcflObjectFile(this, fr);
+  };
 
-  async load() {
-    this._inventory = {};
+  /**
+   * Return a file representation by the logical path and version,
+   * @param { string } logicalPath 
+   * @param { string } [version='latest']
+   */
+  async fileByLogicalPath(logicalPath, version) {
     const inv = await this.getInventory();
-    //await this.loadExtensions();
+    const fr = inv?.getFile(logicalPath, version);
+    if (fr) return new OcflObjectFile(this, fr);
+  };
 
-    //load file metadata from underlying storage
-    const metadata = inv.metadata = {};
-    for await (const file of await this.#store.list(this.root, { recursive: true })) {
-      const contentPath = file.path;
-      metadata[contentPath] = {
-        size: file.size,
-        lastModified: file.lastModified.getTime()
+  /**
+   * Return a file representation by either the [logical path and version], digest, or content path. 
+   * The returned file object can be used to retrieve the content of a file either as string, buffer, or stream.
+   * If the object inventory file is not loaded, this file object will not include the full file metadata information.
+   * If version is omitted, it defaults to the last version.
+   * @param { LogicalPath | FileRefLogical | FileRefDigest | FileRefContent } opt A choice of logical path (eg: 'test') and version (eg: 'v1'), 
+   * digest of the file content, or content path (eg: 'v1/content/test')
+   * @param {string} [version='latest'] The object version name, eg: 'v1', 'v2'. Default to 'latest'. Only used if opt is a LogicalPath.
+   * @param {string} [lazy] If true, always return a file instance even if the object inventory file is not loaded.
+   */
+  getFile(opt, version, lazy) {
+    const inv = this.inventory;
+    /** @type {any} */
+    const file = typeof opt === 'string' ? { logicalPath: opt, version: version } : { ...opt };
+    if (inv) {
+      let fr;
+      if (file.logicalPath) {
+        fr = inv?.getFile(file.logicalPath, file.version);
+      } else if (file.digest) {
+        fr = inv?.getFileByDigest(file.digest, file.version);
+      } else if (file.contentPath) {
+        fr = inv?.getFileByContentPath(file.contentPath, file.version);
       }
+      if (fr) return new OcflObjectFile(this, fr);
+    } else if (lazy) {
+      return new OcflObjectFile(this, file);
     }
-    return;
-  }
+  };
 
   /**
-   * @param {function(OcflObjectTransaction):Promise<*>} [updater]
-   * @param {ObjectUpdateMode} [mode=UPDATE_MODE.MERGE]
+   * Return the latest version of the cached data from inventory.json which can be read using {@link getInventory()}
    */
-  async update(updater, mode = UPDATE_MODE.MERGE) {
-    if (typeof mode === 'string') mode = UPDATE_MODE.of(mode.toUpperCase());
-    if (!mode || !UPDATE_MODE.has(mode)) throw new TypeError(`Invalid mode '${mode.toString()}'`);
-    let inv = await this.getInventory();
-    let newInv = await this._createInventory(inv, mode === UPDATE_MODE.REPLACE);
-    let t = await this.#createTransaction(newInv);
-    if (typeof updater === 'function') {
-      try {
-        await updater(t);
-      } catch (error) {
-        // console.log(error);
-        await t.rollback();
-        throw error;
-      }
-      await t.commit();
-      return;
-    }
-    return t;
-  }
-
-  /** @deprecated */
-  async createReadStream(filePath, options) {
-    return this.#store.createReadStream(path.join(this.root, filePath), options);
-  }
-
-  async createReadable(filePath, options) {
-    return this.#store.createReadable(path.join(this.root, filePath), options);
+  get inventory() {
+    return this._inventory.latest;
   }
 
   /** 
-  @typedef {import('fs').OpenMode} OpenMode
-  @typedef {import('events').Abortable} Abortable
-  @typedef {{ 
-    (relPath: string, options?:({encoding?: null | undefined, flag?: OpenMode | undefined} & Abortable) | null): Promise<Buffer>
-    (relPath: string, options:({encoding: BufferEncoding, flag?: OpenMode | undefined} & Abortable)|BufferEncoding): Promise<string>
-  }} ReadFileFn
+   * Reads the object inventory file and cache it in the memory.
+   * Optionally, preloads and reads all files metadata from the underlying storage.
+   * @param {object} [options]
+   * @param {boolean} [options.filesMetadata] Whether to read file metadata from the underlying storage.
    */
+  async load({ filesMetadata } = {}) {
+    this._inventory = {}; // reset inventory cache
+    const inv = await this.getInventory();
+    //await this.loadExtensions();
+    if (inv && filesMetadata) {
+      //load file metadata from underlying storage
+      const metadata = inv.metadata = {};
+      for await (const file of await this.#store.list(this.root, { recursive: true })) {
+        const contentPath = file.path;
+        metadata[contentPath] = {
+          size: file.size,
+          lastModified: file.lastModified.getTime()
+        }
+      }
+    }
+  }
+
   /** 
-   * Read a file inside an object.
-   * @type {ReadFileFn} abc
+   * Read the content of a file inside an object.
    * @param {string} relPath - The file path relative to the object root.
-   * @param options - Options to be passed to the underlying method
+   * @param {*} options - Options to be passed to the underlying method
    */
-  readFile = async function (relPath, options) {
+  async readFile(relPath, options) {
     return this.#store.readFile(path.join(this.root, relPath), options);
   };
 
-  getFile = function (opt, version) {
-    var obj = this;
-    var opt_ = typeof opt === 'string' ? { logicalPath: opt, version: version } : opt;
-    return new OcflObjectFile(this, opt_);
+  /** 
+   * Get the file metadata such as size and modification time.
+   * @param {string} relPath - The file path relative to the object root.
+   */
+  async stat(relPath) {
+    return this.#store.stat(path.join(this.root, relPath));
   };
 
+  toString() { return `OcflObject { root: ${this.root}, id: ${this.id} }`; }
+
+  toJSON() { return { root: this.root, id: this.id }; }
+
+
+}
+
+
+/**
+ * @implements {OcflObject}
+ */
+class OcflObjectImpl extends OcflObject {
+
   // async _resolveContentPath({ logicalPath = '', contentPath = '', digest = '', version = '' }) {
   //   if (!contentPath) {
   //     let inv = await this.getInventory();
@@ -464,138 +477,7 @@ class OcflObjectImpl extends OcflObject {
   //   return contentPath;
   // }
 
-  // async getAsBuffer(opt) {
-  //   let p = await this._resolveContentPath(opt);
-  //   if (!p) throw new Error(`Cannot find content "${opt.logicalPath || opt.contentPath || opt.digest}" in the OCFL Object "${this.#id}" version "${opt.version || 'latest'}"`);
-  //   return this.readFile(p, opt.options);
-  // }
-  // async getAsString(opt) {
-  //   // @ts-ignore
-  //   return this.getAsBuffer({ ...opt, options: opt.encoding || 'utf8' });
-  // }
-  // async getAsStream(opt) {
-  //   let p = await this._resolveContentPath(opt);
-  //   if (!p) throw new Error(`Cannot find content "${opt.logicalPath || opt.contentPath || opt.digest}" in the OCFL Object "${this.#id}" version "${opt.version || 'latest'}"`);
-  //   return this.createReadStream(p, opt.options);
-  // }
-
-  /**
-   * Copy all content of this Object to a directory in local filesystem
-   * @param {*} targetDir 
-   */
-  async export(targetDir, version) { }
-
-  async exists() {
-    return !(await isDirEmpty(this.#store, this.root));
-  }
-
-  /**
-   * @param {string} [version]
-   */
-  async files(version) {
-    let inv = await this.getInventory();
-    let o = this;
-    function* files() {
-      for (const f of inv.files(version)) {
-        yield new OcflObjectFile(o, f);
-      }
-    }
-    return files();
-  }
-
-
-  /**
-   * Create a new inventory from the object config or clone an existing inventory.
-   * @param {OcflObjectInventory} [inventory]
-   * @param {boolean} [cleanState]
-   * @return {OcflObjectInventoryMut}
-   */
-  _createInventory(inventory, cleanState) {
-    /** @type {Object} */
-    let data;
-    if (inventory) {
-      data = inventory.toJSON();
-    } else {
-      data = {
-        id: this.id,
-        digestAlgorithm: this.digestAlgorithm.value,
-        type: `https://ocfl.io/${this.ocflVersion}/spec/#inventory`
-      };
-      if (this.contentDirectory !== 'content') data.contentDirectory = this.contentDirectory;
-    }
-    return OcflObjectInventory.newVersion(data, cleanState);
-  }
-
-  /**
-   * 
-   * @param {string} absOrRelPath 
-   * @return {string} 
-   */
-  toAbsPath(absOrRelPath = '') {
-    if (!path.isAbsolute(absOrRelPath)) return path.join(this.root, absOrRelPath);
-    return absOrRelPath;
-  }
-
-  /**
-   * Create a new backend-specific update transaction
-   * @param {OcflObjectInventoryMut} inventory
-   * @return {Promise<OcflObjectTransaction>}
-   */
-  async #createTransaction(inventory) {
-    // @todo: validate existing object
-    // check existing 
-    let workspacePath = this.workspace || this.root;
-    let workspaceVersionPath = path.join(workspacePath, inventory.head);
-
-    if (await this.#store.exists(workspaceVersionPath)) {
-      // workspace dir exists, abort update
-      throw new Error('Uncommitted changes detected. Object is being updated by other process or there has been a failed update attempt');
-    }
-    await this._validateObjectPath();
-    let createdDir = await this.#store.mkdir(workspacePath);
-    if (!this.workspace) await this._ensureNamaste();
-    return createTransactionProxy(new OcflObjectTransactionImpl(this, this.#store, inventory, workspaceVersionPath, createdDir));
-  }
-
-  async _ensureNamaste() {
-    let prefix = NAMASTE_PREFIX_OBJECT;
-    let nv = await findNamasteVersion(this.#store, prefix, this.root);
-    if (nv === '') throw validation.createError(6, this.root);
-    if (nv) {
-      if (!this.ocflVersion) this.ocflVersion = nv;
-      return;
-    }
-    // namaste not found, check if object root is not empty
-    let files;
-    try {
-      files = await this.#store.readdir(this.root);
-    } catch (error) {
-    }
-    if (files && files.length > 0) throw new Error('Cannot create an OCFL Object in a non-empty directory');
-    //create the namaste file
-    let filePath = path.join(this.root, NAMASTE_T + prefix + this.ocflVersion);
-    await this.#store.writeFile(filePath, prefix + this.ocflVersion + '\n', 'utf8');
-  }
-
-  // all the parent directories cannot be an ocfl object
-  async _validateObjectPath() {
-    var p = this.root;
-    while (p !== '.' && p !== '/' ) {
-      p = path.dirname(p);
-      let nv = await findNamasteVersion(this.#store, NAMASTE_PREFIX_OBJECT, p);
-      if (nv) throw new Error(`Object root cannot be nested under another object ${p}`);
-    }
-  }
-  
   async isObject(aPath) { }
-  getVersionString(i) { }
-  async determineVersion() { }
-  nameVersion(version) {
-    return 'ocfl_object_' + version;
-  }
-  async digest_dir(dir) { }
-  async hash_file(p) { }
-  async removeEmptyDirectories(folder) { }
   static status(rootPath) { }
   static exists(rootPath) { }
 
@@ -609,48 +491,9 @@ class OcflObjectImpl extends OcflObject {
 };
 
 
-const objectInterface = new OcflObject();
-const proxyHandler = {
-  /**
-   * @param {OcflObject} target 
-   * @param {string} prop 
-   */
-  get(target, prop, receiver) {
-    if (prop in objectInterface) {
-      let p = target[prop];
-      if (typeof p === 'function') {
-        return p.bind(target);
-      } else {
-        return p;
-      }
-    }
-  }
-};
-
-/**
- * Return any OcflObject implementation as OcflObject.
- * @param {OcflObject} impl
- */
-function createObjectProxy(impl) {
-  return new Proxy(impl, proxyHandler);
-}
-
-/**
- * Create an OCFL Object
- * @param {OcflObjectConfig} config
- * @return {OcflObject}
- */
-function createObject(config) {
-  throw new Error('Not Implemented');
-}
-
 module.exports = {
   OcflObject,
-  OcflObjectImpl,
   OcflObjectInventory,
   //OcflObjectTransaction,
-  OcflObjectTransactionImpl,
-  createTransactionProxy,
-  createObjectProxy,
-  createObject
+  OcflObjectTransactionImpl
 };