@dotinc/ogre 0.1.0

package/lib/hash.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Credit goes to https://github.com/juanelas/object-sha
+ *
+ * @remarks
+ * This module runs perfectly in node.js and browsers
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.digest = void 0;
+/**
+ * Returns a string with a hexadecimal representation of the digest of the input object using a given hash algorithm.
+ * It first creates an array of the object values ordered by the object keys (using hashable(obj));
+ * then, it JSON.stringify-es it; and finally it hashes it.
+ *
+ * @param obj - An Object
+ * @param algorithm - For compatibility with browsers it should be 'SHA-1', 'SHA-256', 'SHA-384' and 'SHA-512'.
+ *
+ * @param isBrowser
+ * @throws {RangeError}
+ * Thrown if an invalid hash algorithm is selected.
+ *
+ * @returns a promise that resolves to a string with hexadecimal content.
+ */
+function digest(obj, algorithm = 'SHA-256', isBrowser = false) {
+    const algorithms = ['SHA-1', 'SHA-256', 'SHA-384', 'SHA-512'];
+    if (!algorithms.includes(algorithm)) {
+        throw RangeError(`Valid hash algorithm values are any of ${JSON.stringify(algorithms)}`);
+    }
+    return (async function (obj, algorithm) {
+        const encoder = new TextEncoder();
+        const hashInput = encoder.encode(hashable(obj)).buffer;
+        let digest = '';
+        if (isBrowser) {
+            const buf = await crypto.subtle.digest(algorithm, hashInput);
+            const h = '0123456789abcdef';
+            (new Uint8Array(buf)).forEach((v) => {
+                digest += h[v >> 4] + h[v & 15];
+            });
+        }
+        else {
+            const nodeAlg = algorithm.toLowerCase().replace('-', '');
+            digest = require('crypto').createHash(nodeAlg).update(Buffer.from(hashInput)).digest('hex'); // eslint-disable-line
+        }
+        /* eslint-enable no-lone-blocks */
+        return digest;
+    })(obj, algorithm);
+}
+exports.digest = digest;
+function isObject(val) {
+    return (val != null) && (typeof val === 'object') && !(Array.isArray(val));
+}
+function objectToArraySortedByKey(obj) {
+    if (!isObject(obj) && !Array.isArray(obj)) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => {
+            if (Array.isArray(item) || isObject(item)) {
+                return objectToArraySortedByKey(item);
+            }
+            return item;
+        });
+    }
+    // if it is an object convert to array and sort
+    return Object.keys(obj) // eslint-disable-line
+        .sort()
+        .map((key) => {
+        return [key, objectToArraySortedByKey(obj[key])];
+    });
+}
+/**
+ * If the input object is not an Array, this function converts the object to an array, all the key-values to 2-arrays [key, value] and then sort the array by the keys. All the process is done recursively so objects inside objects or arrays are also ordered. Once the array is created the method returns the JSON.stringify() of the sorted array.
+ *
+ * @param {object} obj the object
+ *
+ * @returns {string} a JSON stringify of the created sorted array
+ */
+const hashable = (obj) => {
+    return JSON.stringify(objectToArraySortedByKey(obj));
+};

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from './interfaces';
+export * from './repository';
+export { Commit } from './commit';
+export * from './ref';
+export * from './size';

package/lib/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./interfaces"), exports);
+tslib_1.__exportStar(require("./repository"), exports);
+tslib_1.__exportStar(require("./ref"), exports);
+tslib_1.__exportStar(require("./size"), exports);

package/lib/interfaces.d.ts

@@ -0,0 +1,14 @@
+import { Commit } from './commit';
+export interface Reference {
+    name: string;
+    value: string;
+}
+export interface Change {
+    path: any[];
+    newValue: any | undefined;
+    oldValue: any | undefined;
+}
+export interface History {
+    refs: Map<string, Reference>;
+    commits: Commit[];
+}

package/lib/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/ref.d.ts

@@ -0,0 +1,2 @@
+export declare function validRef(name: string, onelevel: boolean): boolean;
+export declare function validBranch(name: string): boolean;

package/lib/ref.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validBranch = exports.validRef = void 0;
+const bad = /(^|[/.])([/.]|$)|^@$|@{|[\x00-\x20\x7f~^:?*[\\]|\.lock(\/|$)/;
+const badBranch = /^(-|HEAD$)/;
+function validRef(name, onelevel) {
+    return !bad.test(name) && (onelevel || name.includes('/'));
+}
+exports.validRef = validRef;
+function validBranch(name) {
+    return validRef(name, true) && !badBranch.test(name);
+}
+exports.validBranch = validBranch;

package/lib/repository.d.ts

@@ -0,0 +1,29 @@
+import { History } from './interfaces';
+import { Commit } from './commit';
+export interface RepositoryOptions<T> {
+    history?: History;
+}
+export interface RepositoryObject<T> {
+    data: T;
+    getHistory(): History;
+    head(): string;
+    ref(reference: string): string | undefined;
+    commit(message: string, author: string, amend?: boolean): Promise<string>;
+    checkout(shaish: string, createBranch?: boolean): void;
+    logs(commits?: number): Commit[];
+    createBranch(name: string): string;
+    merge(source: string | RepositoryObject<T> | History): string;
+    branch(): string;
+}
+export interface RespositoryObjectType {
+    new <T>(obj: T, options: RepositoryOptions<T>): RepositoryObject<T>;
+}
+/**
+ * A repository recording and managing the state transitions of an object
+ */
+export declare const Repository: RespositoryObjectType;
+/**
+ * Prints the underlying changelog of a repository
+ * @param repository
+ */
+export declare const printChangeLog: <T>(repository: RepositoryObject<T>) => void;

package/lib/repository.js

@@ -0,0 +1,455 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printChangeLog = exports.Repository = void 0;
+const commit_1 = require("./commit");
+const ref_1 = require("./ref");
+const REFS_HEAD = 'HEAD';
+const REFS_MAIN = 'refs/heads/main';
+const refPrefix = 'ref: ';
+/**
+ * A repository recording and managing the state transitions of an object
+ */
+exports.Repository = function (obj, options) {
+    var _a, _b, _c, _d;
+    let savedLength;
+    let version = 0;
+    const refs = (_b = (_a = options.history) === null || _a === void 0 ? void 0 : _a.refs) !== null && _b !== void 0 ? _b : new Map([[REFS_HEAD, {
+                name: REFS_HEAD,
+                value: `ref: ${REFS_MAIN}`
+            }]]);
+    const changeLog = [];
+    const targets = [];
+    const commits = (_d = (_c = options.history) === null || _c === void 0 ? void 0 : _c.commits) !== null && _d !== void 0 ? _d : [];
+    const hash = new Map([[obj, []]]);
+    const handler = {
+        get: function (target, property) {
+            var _a;
+            const x = target[property];
+            if (Object(x) !== x)
+                return x;
+            const arr = (_a = hash.get(target)) !== null && _a !== void 0 ? _a : [];
+            hash.set(x, [...arr, property]);
+            return new Proxy(x, handler);
+        },
+        set: update,
+        deleteProperty: update
+    };
+    function gotoVersion(newVersion) {
+        newVersion = Math.max(0, Math.min(changeLog.length, newVersion));
+        let chg;
+        let target;
+        let path;
+        let property;
+        const val = newVersion > version ? 'newValue' : 'oldValue';
+        while (version !== newVersion) {
+            if (version > newVersion)
+                version--;
+            chg = changeLog[version];
+            path = [...chg.path];
+            property = path.pop();
+            target =
+                targets[version] ||
+                    (targets[version] = path.reduce((o, p) => o[p], obj));
+            if (chg.hasOwnProperty(val)) {
+                const oldValue = chg[val];
+                // Some additional care concerning the length property of arrays:
+                // @nadilas workaround: array trim to empty array should not set 0:undefined
+                // console.log('warn: not setting array[0]=undefined', target, property, oldValue)
+                if (!(Array.isArray(target) &&
+                    target.length === 0 &&
+                    oldValue === undefined)) {
+                    target[property] = oldValue;
+                }
+            }
+            else {
+                delete target[property];
+            }
+            if (version < newVersion) {
+                version++;
+            }
+        }
+        return true;
+    }
+    function gotoLastVersion() {
+        return gotoVersion(changeLog.length);
+    }
+    function update(target, property, value) {
+        var _a;
+        // only last version can be modified
+        gotoLastVersion();
+        const changes = (_a = hash.get(target)) !== null && _a !== void 0 ? _a : [];
+        const change = {
+            path: [...changes, property],
+            newValue: undefined,
+            oldValue: undefined
+        };
+        if (arguments.length > 2)
+            change.newValue = value;
+        // Some care concerning the length property of arrays:
+        if (Array.isArray(target) && Number(property) >= target.length) {
+            savedLength = target.length;
+        }
+        if (property in target) {
+            if (property === 'length' && savedLength !== undefined) {
+                change.oldValue = savedLength;
+                savedLength = undefined;
+            }
+            else {
+                change.oldValue = target[property];
+            }
+        }
+        changeLog.push(change);
+        targets.push(target);
+        return gotoLastVersion();
+    }
+    this.data = new Proxy(obj, handler);
+    // region Read state read
+    this.head = () => {
+        const ref = refs.get(REFS_HEAD);
+        if (!ref) {
+            throw new Error(`unreachable: HEAD is not present`);
+        }
+        return cleanRefValue(ref.value);
+    };
+    this.ref = (reference) => {
+        var _a;
+        const ref = (_a = refs.get(reference)) === null || _a === void 0 ? void 0 : _a.value;
+        return ref ? cleanRefValue(ref) : undefined;
+    };
+    this.branch = () => {
+        const currentHeadRef = refs.get(REFS_HEAD);
+        if (!currentHeadRef) {
+            throw new Error('unreachable: ref HEAD not available');
+        }
+        if (currentHeadRef.value.includes(refPrefix)) {
+            const refName = cleanRefValue(currentHeadRef.value);
+            if (refs.has(refName))
+                return getLastItem(refName);
+        }
+        return REFS_HEAD; // detached state
+    };
+    // endregion
+    // region History functions
+    const collectCommits = () => {
+        const commit = commitAtHead();
+        if (!commit) {
+            return [];
+        }
+        // traverse backwards and build commit tree
+        let c = commit;
+        let commitsList = [];
+        while (c !== undefined) {
+            commitsList = [c, ...commitsList];
+            c = commits.find(parent => parent.hash === (c === null || c === void 0 ? void 0 : c.parent));
+        }
+        return commitsList;
+    };
+    const rebuildChangeLog = (commit) => {
+        // clear current state
+        changeLog.splice(0);
+        version = 0;
+        // traverse backwards and build changelog
+        let clog = traverseAndCollectChangelog(commit, commits);
+        changeLog.push(...clog);
+        // process new changelog
+        gotoLastVersion();
+    };
+    this.logs = (numberOfCommits) => {
+        const logs = [];
+        const limit = numberOfCommits !== null && numberOfCommits !== void 0 ? numberOfCommits : -1;
+        let c = commitAtHead();
+        let counter = 0;
+        while (c !== undefined && (limit === -1 || counter < limit)) {
+            logs.push(c, ...logs);
+            counter++;
+            c = commits.find(parent => parent.hash === (c === null || c === void 0 ? void 0 : c.parent));
+        }
+        return logs;
+    };
+    // endregion
+    this.getHistory = () => {
+        // only send back shallow copies of changelog and commits up to current version
+        return {
+            refs: new Map(refs),
+            commits: collectCommits()
+        };
+    };
+    // region Commit lookups
+    const commitAtHead = () => {
+        return commitAtHeadIn(REFS_HEAD, refs, commits);
+    };
+    const mustCommitAtHead = () => {
+        const commitHead = commitAtHead();
+        if (!commitHead) {
+            throw new Error(`unreachable: HEAD or its target ref not present`);
+        }
+        return commitHead;
+    };
+    // endregion
+    this.commit = async (message, author, amend = false) => {
+        let parent = commitAtHead();
+        if (amend && !parent) {
+            throw new Error(`no commit to amend`);
+        }
+        if (parent) {
+            if (amend) {
+                [parent] = parent.parent ? shaishToCommit(parent.parent, refs, commits) : [undefined];
+            }
+        }
+        const changesSinceLastCommit = changeLog.slice(parent === null || parent === void 0 ? void 0 : parent.to);
+        if (changesSinceLastCommit.length === 0) {
+            throw new Error(`no changes to commit`);
+        }
+        const timestamp = new Date();
+        const changes = [...changesSinceLastCommit];
+        const sha = await (0, commit_1.calculateHash)({
+            message,
+            author,
+            changes,
+            parentRef: parent === null || parent === void 0 ? void 0 : parent.hash,
+            timestamp
+        });
+        const commit = {
+            hash: sha,
+            message,
+            author,
+            changes: changes,
+            parent: parent === null || parent === void 0 ? void 0 : parent.hash,
+            timestamp,
+            to: version
+        };
+        if (amend) {
+            const idx = commits.findIndex(c => c === parent);
+            commits.splice(idx, 1);
+        }
+        commits.push(commit);
+        const headRef = this.head();
+        if (headRef.includes('refs')) {
+            // but move ref: refs/heads/main
+            moveRef(headRef, commit);
+        }
+        else {
+            // move detached HEAD to new commit
+            moveRef(REFS_HEAD, commit);
+        }
+        return sha;
+    };
+    // region Graph manipulation
+    this.checkout = (shaish, createBranch = false) => {
+        if (createBranch) {
+            validateBranchName(shaish);
+            let branchRef = brancheNameToRef(shaish);
+            const commit = commitAtHead();
+            if (commit) {
+                moveRef(branchRef, commit);
+            }
+            moveRef(REFS_HEAD, branchRef);
+        }
+        else {
+            const [commit, isRef, refKey] = shaishToCommit(shaish, refs, commits);
+            rebuildChangeLog(commit);
+            moveRef(REFS_HEAD, isRef && refKey !== undefined ? refKey : commit);
+        }
+    };
+    this.createBranch = (name) => {
+        validateBranchName(name);
+        const refName = brancheNameToRef(name);
+        const headCommit = commitAtHead();
+        if (!headCommit) {
+            const headRef = this.head();
+            if (!headRef) {
+                throw new Error(`unreachable: HEAD not present`);
+            }
+            throw new Error(`fatal: not a valid object name: '${getLastItem(headRef)}'`);
+        }
+        refs.set(refName, { name: name, value: headCommit.hash });
+        return refName;
+    };
+    const moveRef = (refName, value) => {
+        let ref = refs.get(refName);
+        const val = typeof value === 'string' ? `${refPrefix}${value}` : value.hash;
+        if (!ref) {
+            ref = { name: getLastItem(refName), value: val };
+        }
+        else {
+            ref.value = val;
+        }
+        refs.set(refName, ref);
+    };
+    this.merge = source => {
+        // inspiration
+        // http://think-like-a-git.net
+        // also check isomorphic-git
+        //   for fancier merge tree
+        //   https://github.com/isomorphic-git/isomorphic-git/blob/a623133345a5d8b6bb7a8352ea9702ce425d8266/src/utils/mergeTree.js#L33
+        if (typeof source !== 'string') {
+            // const srcHead = commitAtHeadIn(REFS_HEAD, src.refs, src.commits)
+            throw new Error(`fatal: source type (${source instanceof exports.Repository ? 'Repository' : 'History'}) not implemented`);
+        }
+        const [srcCommit] = shaishToCommit(source, refs, commits);
+        const headCommit = mustCommitAtHead();
+        // no change
+        // *---* (master)
+        //     |
+        //     * (foo)
+        if (headCommit.hash === srcCommit.hash) {
+            throw new Error(`already up to date`);
+        }
+        // fast-forward
+        // *---* (master)
+        //      \
+        //       *---*---* (foo)
+        // result:
+        // *---*
+        //      \
+        //       *---*---* (master, foo)
+        const [isAncestor] = mapPath(headCommit, srcCommit, commits);
+        if (isAncestor) {
+            moveRef(this.head(), srcCommit);
+            rebuildChangeLog(srcCommit);
+            return srcCommit.hash;
+        }
+        // todo diverge
+        // *---*---* (master)
+        //      \
+        //       *---*---* (foo)
+        // result:
+        //                 ↓
+        // *---*---*-------* (master)
+        //      \         /
+        //       *---*---* (foo)
+        // if (false) {
+        //  throw new Error('diverge not implemented yet')
+        // }
+        throw new Error('unknown merge type: not implemented yet');
+    };
+    // endregion
+    // apply change log at the end of the constructor
+    const headCommit = commitAtHead();
+    if (headCommit) {
+        rebuildChangeLog(headCommit);
+    }
+};
+const getLastItem = (thePath) => thePath.substring(thePath.lastIndexOf('/') + 1);
+const cleanRefValue = (ref) => ref.replace(refPrefix, '');
+const brancheNameToRef = (name) => {
+    return `refs/heads/${name}`;
+};
+const validateBranchName = (name) => {
+    if (!(0, ref_1.validBranch)(name)) {
+        throw new Error(`invalid ref name`);
+    }
+};
+/**
+ * Traverses the commit tree backwards and reassembles the changelog
+ * @param commit
+ * @param commitsList
+ */
+const traverseAndCollectChangelog = (commit, commitsList) => {
+    let c = commit;
+    let clog = [];
+    while (c !== undefined) {
+        clog = [...commit.changes, ...clog];
+        c = commitsList.find(parent => parent.hash === (c === null || c === void 0 ? void 0 : c.parent));
+    }
+    return clog;
+};
+const mapPath = (from, to, commits) => {
+    let c = to;
+    while (c !== undefined) {
+        c = commits.find(parent => parent.hash === (c === null || c === void 0 ? void 0 : c.parent));
+        if ((c === null || c === void 0 ? void 0 : c.hash) === from.hash) {
+            return [true];
+        }
+    }
+    return [false];
+};
+/**
+ * Returns the commit to which the provided ref is pointing
+ * @param ref - needs to be in key format, e.g. refs/heads/... or refs/tags/...
+ * @param references
+ * @param commitsList
+ */
+const commitAtHeadIn = (ref, references, commitsList) => {
+    const reference = references.get(ref);
+    if (!reference) {
+        throw new Error(`unreachable: '${ref}' is not present`);
+    }
+    let commitHash;
+    if (reference.value.includes(refPrefix)) {
+        const refKey = cleanRefValue(reference.value);
+        const targetRef = references.get(refKey);
+        if (!targetRef) {
+            // target branch may not have been saved yet
+            return undefined;
+        }
+        commitHash = targetRef.value;
+    }
+    else {
+        commitHash = reference.value;
+    }
+    for (const c of commitsList) {
+        if (c.hash === commitHash) {
+            return c;
+        }
+    }
+    return undefined;
+};
+/**
+ * Accepts a shaish expression (e.g. refs (branches, tags), commitSha) and returns
+ * - a commit of type Commit
+ * - isRef boolean whether it is a direct reference
+ * - ref the key of the reference
+*/
+const shaishToCommit = (shaish, references, commitsList) => {
+    let sha = shaish;
+    let isRef = false;
+    let refKey = undefined;
+    // check for refs
+    for (const [name, ref] of references.entries()) {
+        // match on
+        if (ref.name === shaish || name === shaish) {
+            isRef = true;
+            refKey = name;
+            sha = ref.value;
+            if (sha.includes(refPrefix)) {
+                const cleanedRef = cleanRefValue(sha);
+                const c = commitAtHeadIn(cleanedRef, references, commitsList);
+                if (!c) {
+                    throw new Error(`${cleanedRef} points to non-existing commit`);
+                }
+                return [c, isRef, refKey];
+            }
+            break;
+        }
+    }
+    // check for partial sha matches
+    const found = commitsList.filter(c => c.hash.indexOf(sha) > -1);
+    if (found.length === 0) {
+        throw new Error(`pathspec '${shaish}' did not match any known refs`);
+    }
+    // but sha should be specific enough to resolve to 1 commit
+    if (found.length > 1) {
+        throw new Error(`commit `);
+    }
+    return [found[0], isRef, refKey];
+};
+/**
+ * Prints the underlying changelog of a repository
+ * @param repository
+ */
+const printChangeLog = (repository) => {
+    console.log('----------------------------------------------------------');
+    console.log(`Changelog at ${repository.head()}`);
+    const history = repository.getHistory();
+    const head = commitAtHeadIn(repository.head(), history.refs, history.commits);
+    if (!head) {
+        throw new Error(`fatal: HEAD is not defined`);
+    }
+    const changeLog = traverseAndCollectChangelog(head, history.commits);
+    for (const [, chg] of changeLog.entries()) {
+        console.log(`  ${JSON.stringify(chg)}`);
+    }
+    console.log('----------------------------------------------------------');
+};
+exports.printChangeLog = printChangeLog;

package/lib/size.d.ts

@@ -0,0 +1,4 @@
+export declare const getSizeInBytes: (obj: string | any) => number;
+export declare const sizeInBytes: (obj: any) => number;
+export declare const sizeInKilobytes: (obj: any) => number;
+export declare const sizeInMegabytes: (obj: any) => number;

package/lib/size.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sizeInMegabytes = exports.sizeInKilobytes = exports.sizeInBytes = exports.getSizeInBytes = void 0;
+const getSizeInBytes = (obj) => {
+    let str;
+    if (typeof obj === 'string') {
+        // If obj is a string, then use it
+        str = obj;
+    }
+    else {
+        // Else, make obj into a string
+        str = JSON.stringify(obj);
+    }
+    // Get the length of the Uint8Array
+    return new TextEncoder().encode(str).length; // in bytes
+};
+exports.getSizeInBytes = getSizeInBytes;
+const sizeInBytes = (obj) => {
+    return (0, exports.getSizeInBytes)(obj); // B
+};
+exports.sizeInBytes = sizeInBytes;
+const sizeInKilobytes = (obj) => {
+    const bytes = (0, exports.getSizeInBytes)(obj);
+    return (bytes / 1000); // kB
+};
+exports.sizeInKilobytes = sizeInKilobytes;
+const sizeInMegabytes = (obj) => {
+    const bytes = (0, exports.getSizeInBytes)(obj);
+    return (bytes / 1000 / 1000); // mB
+};
+exports.sizeInMegabytes = sizeInMegabytes;

package/lib/test.utils.d.ts

@@ -0,0 +1,17 @@
+import { RepositoryObject } from './repository';
+import { Commit } from './commit';
+export declare class NestedObject {
+    name: string | undefined;
+    uuid: string | undefined;
+}
+export declare class ComplexObject {
+    uuid: string | undefined;
+    name: string | undefined;
+    description: string | undefined;
+    nested: NestedObject[];
+}
+export declare const testAuthor = "User name <name@domain.com>";
+export declare function getBaseline(): Promise<[RepositoryObject<ComplexObject>, ComplexObject]>;
+export declare function updateHeaderData(wrapped: ComplexObject): number;
+export declare function addOneStep(wrapped: ComplexObject): number;
+export declare function sumChanges(commits: Commit[] | undefined): number | undefined;