@ocfl/ocfl 0.1.0 → 0.1.1

package/index.js

@@ -108,8 +108,19 @@ class Ocfl {
   storage(config, storeOptions = this.#defaultOptions) {
     return new OcflStorageImpl(config, this.#store.getInstance(storeOptions));
   }
+
 }
 
+class Storage {
+  async create(config) {
+
+  }
+  async load(config) {
+
+  }
+} 
+
+
 module.exports = {
   OcflConstants,
   OcflDigest,

package/lib/extensions/0003-hash-and-id-n-tuple-storage-layout.js

@@ -28,8 +28,8 @@ class HashAndIdNTupleStorageLayout extends OcflStorageLayout {
   /**
    * @param {Partial<typeof DefaultConfig>} [config] 
    */
-   constructor(config) {
-    super(config);
+  constructor(config) {
+    super(config, DefaultConfig);
     let c = this.parameters;
     if (!OcflDigest.FIXITY.of(c.digestAlgorithm)) throw new Error('Invalid digestAlgorithm');
     let digest = OcflDigest.digestSync(c.digestAlgorithm, 'test');
@@ -42,10 +42,10 @@ class HashAndIdNTupleStorageLayout extends OcflStorageLayout {
    * @return {string} 
    */
   map(id) {
-    let digest = OcflDigest.digestSync(this.config.digestAlgorithm, id);
+    let digest = OcflDigest.digestSync(this.parameters.digestAlgorithm, id);
     let segments = [];
-    let s = this.config.tupleSize;
-    let n = this.config.numberOfTuples;
+    let s = this.parameters.tupleSize;
+    let n = this.parameters.numberOfTuples;
     let i;
     for (i = 0; i < n; ++i) {
       segments.push(digest.slice(s * i, s * i + s));

package/lib/inventory.js

@@ -155,13 +155,20 @@ class OcflObjectInventory {
    * @param {string} [version] - The version name 
    */
   *files(version) {
-    let state = (!version || version === 'latest') ? this.state : this.versions[version]?.state;
+    let state;
+    if (!version || version === 'latest') {
+      state = this.state;
+      version = this.head;
+    } else {
+      state = this.versions[version]?.state;
+    }
     for (let digest in state) {
       let files = state[digest];
       let contentPath = this.getContentPath(digest);
       for (let logicalPath of files) {
         yield {
           logicalPath,
+          version,
           digest,
           contentPath
         };
@@ -283,14 +290,13 @@ class OcflObjectInventoryMut extends OcflObjectInventory {
       if (mf && mf.length > 0) {
         // this is a reinstatement
       } else {
-        if (this.#byPath[logicalPath]) {
-          // this is an update, remove old digest
-          this.delete(logicalPath);
-        } else {
-          // normal addition
-        }
+        // normal addition
         this.manifest[digest] = [path.join(this.head, this.contentDirectory, logicalPath)];
       }
+      if (this.#byPath[logicalPath]) {
+        // this is an update, remove old digest
+        this.delete(logicalPath);
+      }
       state[digest] = [logicalPath];
     }
     this.#byPath[logicalPath] = digest;
@@ -350,6 +356,10 @@ class OcflObjectInventoryMut extends OcflObjectInventory {
     }
   }
 
+  /**
+   * Delete a file
+   * @param {string} logicalPath 
+   */
   delete(logicalPath) {
     let prefix = logicalPath.endsWith('/') ? logicalPath : logicalPath + '/';
     let names = this.getDigest(logicalPath) ? [logicalPath] :

package/lib/object.js

@@ -11,6 +11,7 @@ const { OcflStore } = require('./store.js');
 const { OcflExtension } = require('./extension.js');
 const { NotImplementedError } = require('./error.js');
 const { parallelize, dataSourceAsIterable, isDirEmpty, findNamasteVersion } = require('./utils');
+const { format } = require('util');
 const { OCFL_VERSION, OCFL_VERSIONS, INVENTORY_NAME, NAMASTE_PREFIX_OBJECT, NAMASTE_T } = require('./constants').OcflConstants;
 
 class UPDATE_MODE extends Enum {
@@ -31,18 +32,86 @@ const DIGEST = OcflDigest.CONTENT;
  * @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 {{logicalPath: string; digest: string; contentPath: string;}} FileRef
- */
 /**
  * @typedef {UPDATE_MODE | ('MERGE' | 'REPLACE') } ObjectUpdateMode
+ * 
+ * @typedef {{logicalPath?: string, digest?: string, contentPath?: string, version?: string}} FileRef
+ * @typedef {{logicalPath: string, version?: string}} FileRefLogical
+ * @typedef {{digest: string}} FileRefDigest
+ * @typedef {{contentPath: string}} FileRefContent
  */
-/**
- *
- */
-const defaultConfig = {
-  ocflVersion: OCFL_VERSION
-};
+
+class OcflObjectFile {
+  #ocflObject;
+  /**
+   * 
+   * @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;
+  }
+
+  /**
+   * 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();
+      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;
+  }
+
+  toString() {
+    let o = {};
+    for (const key in ['logicalPath', 'version', 'digest', 'contentPath']) {
+      if (this[key]) o[key] = this[key];
+    }
+    return format('%O', o);
+  }
+
+  /**
+   * Get the file content as a buffer
+   * @param {*} [options] Options to be passed to underlying data store specific implementation
+
+   * @return {Promise<Buffer>}
+   */
+  async asBuffer(options) {
+    return this.#ocflObject.readFile(await this.#resolveContentPath(), options);
+  }
+
+  /**
+   * Get the file content as a string
+   * @param {BufferEncoding} [encoding='utf8'] String encoding, default to utf8
+   * @return {Promise<string>}
+   */
+  async asString(encoding = 'utf8') {
+    // @ts-ignore
+    return this.asBuffer(encoding);
+  }
+
+  /**
+   * Get the file content as a stream
+   * @param {*} [options] Options to be passed to underlying data store specific implementation
+   * @return {Promise<NodeJS.ReadableStream>}
+   */
+  async asStream(options) {
+    return this.#ocflObject.createReadStream(await this.#resolveContentPath(), options);
+  }
+}
+
 
 /**
  * Interface class representing OCFL Object
@@ -66,8 +135,6 @@ class OcflObject {
 
   toJSON() { return { root: this.root, id: this.id }; }
 
-  async inventory(id, dir) { }
-
   /**
    * If a cache exists, return the cached inventory. Otherwise read it from the storage and cache it.
    * @param {string} [version] - Full name of the version, eg: v1, v2, v3  
@@ -124,6 +191,7 @@ class OcflObject {
   }
 
   async load() {
+    this._inventory = {};
     await this.getInventory();
     //await this.loadExtensions();
     return;
@@ -131,47 +199,32 @@ class OcflObject {
 
   /**
    * Iterate through the content files contained in the specified version. 
-   * Returns an array of logical paths in no particular order
+   * Returns an array of FileRef which consists of logical path, content path, and digest, in no particular order
    * @param {string} [version]
-   * @return {Promise<Generator<FileRef, void, unknown>>}
+   * @return {Promise<Generator<OcflObjectFile, void, unknown>>}
    */
   async files(version) { throw new Error('Not Implemented'); }
 
   /**
-  * Get content file as buffer. Either one of the logicalPath, contentPath, or digest parameters must be specified.
-  * @param {Object} opt
-  * @param {string} [opt.logicalPath] - Logical path of the file, eg: `test`
-  * @param {string} [opt.contentPath] - Content path of the file, eg: `v1/content/test`
-  * @param {string} [opt.digest] - Digest of the file content
-  * @param {string} [opt.version] - Version name
-  * @param {*} [opt.options] - Options to be passed to underlying fs
-  * @return {Promise<Buffer>}
-  */
-  async getAsBuffer(opt) { 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 content file as string
-   * @param {Object} opt
-   * @param {string} [opt.logicalPath]
-   * @param {string} [opt.contentPath] 
-   * @param {string} [opt.digest] 
-   * @param {string} [opt.version] 
-   * @param {BufferEncoding} [opt.encoding] 
-   * @return {Promise<string>}
+   * 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}
    */
-  async getAsString(opt) { throw new Error('Not Implemented'); }
-
   /**
-   * Get content file as a stream. Either one of the logicalPath, contentPath, or digest parameters must be specified.
-   * @param {Object} opt
-   * @param {string} [opt.logicalPath] - Logical path of the file, eg: `test`
-   * @param {string} [opt.contentPath] - Content path of the file, eg: `v1/content/test`
-   * @param {string} [opt.digest] - Digest of the file content
-   * @param {string} [opt.version] - Version name
-   * @param {*} [opt.options] - Options to be passed to underlying fs
-   * @return {Promise<NodeJS.ReadableStream>}
+   * Retrieve the content of a file either as string, buffer, or stream.
+   * @type { GetFileByLogical & GetFileByOpt }
    */
-  async getAsStream(opt) { throw new Error('Not Implemented'); }
+  // @ts-ignore
+  getFile = function (opt, version) { }
 
   /**
    * Count the number of files contained in this object
@@ -187,7 +240,9 @@ 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 exists() { throw new Error('Not Implemented'); }
+
+  //async inventory(version = 'latest') { }
 
 }
 
@@ -298,18 +353,8 @@ class OcflObjectImpl extends OcflObject {
     return t;
   }
 
-  /**
-   * Return absolute path to the `contentPath` given either the `logicalPath`, `digest` or `contentPath` with a specific version 
-   * @param {*} param0 
-   * @returns 
-   */
-  async _resolveContentPath({ logicalPath = '', contentPath = '', digest = '', version = '' }) {
-    if (!contentPath) {
-      let inv = await this.getInventory();
-      version = version || inv.head;
-      contentPath = inv.getContentPath(digest || inv.getDigest(logicalPath, version));
-    }
-    return contentPath;
+  async createReadStream(filePath, options) {
+    return this.#store.createReadStream(path.join(this.root, filePath), options);
   }
 
   /** 
@@ -321,54 +366,44 @@ class OcflObjectImpl extends OcflObject {
   }} ReadFileFn
    */
   /** 
-   * Read a file inside an object. 
-   * @param filePath - The file path relative to the object root.
+   * Read a file inside an object.
+   * @type {ReadFileFn} abc
+   * @param {string} relPath - The file path relative to the object root.
    * @param options - Options to be passed to the underlying method
-   * @type ReadFileFn
    */
-  readFile = async function (filePath, options) {
-    return this.#store.readFile(path.join(this.root, filePath), options);
+  readFile = async function (relPath, options) {
+    return this.#store.readFile(path.join(this.root, relPath), options);
   }
 
-  /**
-   * 
-   * @param {Object} opt
-   * @param {string} [opt.logicalPath]
-   * @param {string} [opt.contentPath] 
-   * @param {string} [opt.digest] 
-   * @param {string} [opt.version] 
-   * @param {*} [opt.options] 
-   */
-  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);
+  getFile = function (opt, version) {
+    var obj = this;
+    var opt_ = typeof opt === 'string' ? { logicalPath: opt, version: version } : opt;
+    return new OcflObjectFile(this, opt_);
   }
 
-  /**
-   * 
-   * @param {Object} opt
-   * @param {string} [opt.logicalPath]
-   * @param {string} [opt.contentPath] 
-   * @param {string} [opt.digest] 
-   * @param {string} [opt.version] 
-   * @param {BufferEncoding} [opt.encoding]
-   * @return {Promise<string>} 
-   */
-  async getAsString(opt) {
-    // @ts-ignore
-    return this.getAsBuffer({ ...opt, options: opt.encoding || 'utf8' });
-  }
-
-  async createReadStream(filePath, options) {
-    return this.#store.createReadStream(path.join(this.root, filePath), options);
-  }
-
-  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.#store.createReadStream(p, opt.options);
-  }
+  // async _resolveContentPath({ logicalPath = '', contentPath = '', digest = '', version = '' }) {
+  //   if (!contentPath) {
+  //     let inv = await this.getInventory();
+  //     version = version && version !== 'latest' ? version : inv.head;
+  //     contentPath = inv.getContentPath(digest || inv.getDigest(logicalPath, version));
+  //   }
+  //   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
@@ -385,7 +420,13 @@ class OcflObjectImpl extends OcflObject {
    */
   async files(version) {
     let inv = await this.getInventory();
-    return inv.files(version);
+    let o = this;
+    function* files() {
+      for (const f of inv.files(version)) {
+        yield new OcflObjectFile(o, f);
+      }
+    }
+    return files();
   }
 
 

package/lib/storage.js

@@ -21,7 +21,8 @@ const DEFAULT_LAYOUT = HashedNTupleStorageLayout;
  */
 
 class OcflStorage {
-  static LAYOUT;
+  //static LAYOUT;
+  ocflVersion;
 
   /**
    * Get the storage root
@@ -100,6 +101,7 @@ class OcflStorage {
   async delete(id) {
     return this.remove(id);
   }
+  
   async purge(id) {
     return this.remove(id);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ocfl/ocfl",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Oxford Common File Layout (OCFL) JS library",
   "main": "index.js",
   "exports": {