@teambit/legacy-bit-id 1.0.3 → 1.1.0

package/bit-id.spec.ts

@@ -0,0 +1,225 @@
+import { expect } from 'chai';
+
+import BitId from './bit-id';
+import { InvalidName, InvalidScopeName } from './exceptions';
+
+describe('Bit-id', () => {
+  // TODO: those tests are now verified by TS compiler, I think we can remove them
+  it('should be frozen', () => {
+    const bitId = new BitId({ name: 'my-name' });
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    expect(() => (bitId.scope = 'name')).to.throw();
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    expect(() => (bitId.name = 'name')).to.throw();
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    expect(() => (bitId.version = 'name')).to.throw();
+  });
+  describe('constructor', () => {
+    it('should not throw for an invalid scope as it hurts performance (it is done on .parse() instead)', () => {
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      const invalidScope = () => new BitId({ scope: 123, name: 'my-name' });
+      expect(invalidScope).to.not.throw(InvalidScopeName);
+    });
+    it('should not throw for an invalid name as it hurts performance (it is done on .parse() instead)', () => {
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      const invalidName = () => new BitId({ name: ['a', 'b'] });
+      expect(invalidName).to.not.throw(InvalidName);
+    });
+    it('should accept an empty scope', () => {
+      const invalidScope = () => new BitId({ scope: null, name: 'my-name' });
+      expect(invalidScope).to.not.throw();
+    });
+    it('should not accept an empty name', () => {
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      expect(() => new BitId({ scope: 'my-scope', name: null })).to.throw(InvalidName);
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      expect(() => new BitId({ scope: 'my-scope', name: undefined })).to.throw(InvalidName);
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      expect(() => new BitId({ scope: 'my-scope' })).to.throw(InvalidName);
+    });
+  });
+  describe('changeScope', () => {
+    it('should return a new BitId with different scope', () => {
+      const bitId = new BitId({ name: 'my-name' });
+      expect(bitId.changeScope('my-scope')).to.have.property('scope').that.equal('my-scope');
+    });
+    it('should accept an empty parameter to remove the scope', () => {
+      const bitId = new BitId({ scope: 'my-scope', name: 'my-name' });
+      expect(bitId.changeScope()).to.have.property('scope').that.is.null;
+    });
+  });
+  describe('changeVersion', () => {
+    it('should return a new BitId with different version', () => {
+      const bitId = new BitId({ name: 'my-name' });
+      expect(bitId.changeVersion('0.0.1')).to.have.property('version').that.equal('0.0.1');
+    });
+    it('should accept an empty parameter to remove the version', () => {
+      const bitId = new BitId({ scope: 'my-scope', name: 'my-name', version: '0.0.1' });
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      expect(bitId.changeVersion()).to.have.property('version').that.is.undefined;
+    });
+  });
+  describe('hasScope', () => {
+    it('should return false when there is no scope', () => {
+      const bitId = new BitId({ name: 'my-name' });
+      expect(bitId.hasScope()).to.be.false;
+    });
+    it('should return true when there is scope', () => {
+      const bitId = new BitId({ scope: 'my-scope', name: 'my-name' });
+      expect(bitId.hasScope()).to.be.true;
+    });
+  });
+  describe('getValidBitId', () => {
+    it('should convert CSSComp to css-comp', () => {
+      const bitName = 'CSSComp';
+      expect(BitId.getValidBitId('global', bitName).toString()).to.equal('global/css-comp');
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    });
+    it('should convert EN-US to en-us', () => {
+      const bitName = 'EN-US';
+      expect(BitId.getValidBitId('global', bitName).toString()).to.equal('global/en-us');
+    });
+    it('should convert AppBar to app-bar', () => {
+      const bitName = 'AppBar';
+      expect(BitId.getValidBitId('global', bitName).toString()).to.equal('global/app-bar');
+    });
+    it('should convert app-bar to app-bar', () => {
+      const bitName = 'app-bar';
+      expect(BitId.getValidBitId('global', bitName).toString()).to.equal('global/app-bar');
+    });
+    it('should convert app-Bar to app-bar', () => {
+      const bitName = 'app-Bar';
+      expect(BitId.getValidBitId('global', bitName).toString()).to.equal('global/app-bar');
+    });
+    it('should convert App-Bar to app-bar', () => {
+      const bitName = 'App-Bar';
+      expect(BitId.getValidBitId('global', bitName).toString()).to.equal('global/app-bar');
+    });
+    it('should convert CSScomp to cs-scomp ', () => {
+      const bitName = 'CSScomp';
+      expect(BitId.getValidBitId('global', bitName).toString()).to.equal('global/cs-scomp');
+    });
+    it('should convert CSS@comp/CSScomp to css@comp/cs-scomp ', () => {
+      const bitName = 'CSScomp';
+      const global = 'CSS@comp';
+      expect(BitId.getValidBitId(global, bitName).toString()).to.equal('css@comp/cs-scomp');
+    });
+    it('should convert CSS!!####@comp/app-Bar to app-Bar', () => {
+      const bitName = 'app-Bar';
+      const global = 'CSS!!####@comp';
+      expect(BitId.getValidBitId(global, bitName).toString()).to.equal('css!!####@comp/app-bar');
+    });
+    it('should convert app bar to app-bar', () => {
+      const bitName = 'app bar';
+      expect(BitId.getValidBitId(undefined, bitName).toString()).to.equal('app-bar');
+    });
+  });
+  describe('toString', () => {
+    it('should not contain the version as latest', () => {
+      const bitId = BitId.parse('bit.envs/mocha/react@latest');
+      expect(bitId.toString()).to.equal('bit.envs/mocha/react');
+    });
+  });
+  describe('parse', () => {
+    it('should parse id with scope correctly', () => {
+      const bitId = BitId.parse('scope/my/long/comp/id', true);
+      expect(bitId.scope).to.equal('scope');
+      expect(bitId.name).to.equal('my/long/comp/id');
+      expect(bitId.box).to.be.undefined;
+      expect(bitId.version).to.equal('latest');
+    });
+    it('should parse id without scope correctly', () => {
+      const bitId = BitId.parse('scope/my/long/comp/id', false);
+      expect(bitId.scope).to.be.null;
+      expect(bitId.name).to.equal('scope/my/long/comp/id');
+      expect(bitId.box).to.be.undefined;
+      expect(bitId.version).to.equal('latest');
+    });
+    it('should throw for an invalid id', () => {
+      const bitId = () => BitId.parse('scope/my/long/co*mp/id', false);
+      expect(bitId).to.throw();
+    });
+  });
+  describe('hasSameScope', () => {
+    it('should return true when it has the same scope', () => {
+      const bitId = new BitId({ scope: 'my-scope', name: 'my-name' });
+      const anotherId = new BitId({ scope: 'my-scope', name: 'another-name' });
+      expect(bitId.hasSameScope(anotherId)).to.be.true;
+    });
+    it('should return false when it does not the same scope', () => {
+      const bitId = new BitId({ scope: 'my-scope', name: 'my-name' });
+      const anotherId = new BitId({ scope: 'another-scope', name: 'my-name' });
+      expect(bitId.hasSameScope(anotherId)).to.be.false;
+    });
+    it('should return true when both scopes are null', () => {
+      const bitId = new BitId({ scope: null, name: 'my-name' });
+      const anotherId = new BitId({ scope: null, name: 'my-name' });
+      expect(bitId.hasSameScope(anotherId)).to.be.true;
+    });
+    it('should return false when one of the scope is null', () => {
+      const bitId = new BitId({ scope: null, name: 'my-name' });
+      const anotherId = new BitId({ scope: 'another-scope', name: 'my-name' });
+      expect(bitId.hasSameScope(anotherId)).to.be.false;
+    });
+  });
+  describe('isEqual', () => {
+    it('should return true for an exact match', () => {
+      const bitId = new BitId({ scope: 'my-scope', name: 'my-name', version: '0.0.1' });
+      const anotherId = new BitId({ scope: 'my-scope', name: 'my-name', version: '0.0.1' });
+      expect(bitId.isEqual(anotherId)).to.be.true;
+    });
+    it('should return false for a version mismatch', () => {
+      const bitId = new BitId({ scope: 'my-scope', name: 'my-name', version: '0.0.1' });
+      const anotherId = new BitId({ scope: 'my-scope', name: 'my-name', version: '0.0.2' });
+      expect(bitId.isEqual(anotherId)).to.be.false;
+    });
+    it('should return false for a name mismatch', () => {
+      const bitId = new BitId({ scope: 'my-scope', name: 'my-name', version: '0.0.1' });
+      const anotherId = new BitId({ scope: 'my-scope', name: 'another-name', version: '0.0.1' });
+      expect(bitId.isEqual(anotherId)).to.be.false;
+    });
+    it('should return false for a scope mismatch', () => {
+      const bitId = new BitId({ scope: 'my-scope', name: 'my-name', version: '0.0.1' });
+      const anotherId = new BitId({ scope: 'another-scope', name: 'my-name', version: '0.0.1' });
+      expect(bitId.isEqual(anotherId)).to.be.false;
+    });
+  });
+  describe('serialize', () => {
+    it('should delete the scope property if not set', () => {
+      const bitId = new BitId({ name: 'my-name', version: '0.0.1' });
+      expect(bitId.serialize()).to.not.have.property('scope');
+    });
+    it('should delete the version property if not set', () => {
+      const bitId = new BitId({ name: 'my-name' });
+      expect(bitId.serialize()).to.not.have.property('version');
+    });
+    it('should include all properties if they are all set', () => {
+      const bitId = new BitId({ scope: 'my-scope', name: 'my-name', version: '0.0.1' });
+      expect(bitId.serialize()).to.have.property('name');
+      expect(bitId.serialize()).to.have.property('scope');
+      expect(bitId.serialize()).to.have.property('version');
+    });
+    it('should not be an instance of BitId', () => {
+      const bitId = new BitId({ scope: 'my-scope', name: 'my-name', version: '0.0.1' });
+      expect(bitId.serialize()).to.not.be.an.instanceof(BitId);
+    });
+  });
+  describe('parseBackwardCompatible', () => {
+    it('should parse the new format, which is an object', () => {
+      const bitIdObj = new BitId({ scope: 'my-scope', name: 'my-name', version: '0.0.1' }).serialize();
+      const bitId = BitId.parseBackwardCompatible(bitIdObj);
+      expect(bitId).to.be.an.instanceof(BitId);
+      expect(bitId.name).to.equal('my-name');
+      expect(bitId.scope).to.equal('my-scope');
+      expect(bitId.version).to.equal('0.0.1');
+    });
+    it('should parse the old format, which is a string', () => {
+      const bitIdStr = 'my-scope/my-box/my-name@0.0.1';
+      const bitId = BitId.parseBackwardCompatible(bitIdStr);
+      expect(bitId).to.be.an.instanceof(BitId);
+      expect(bitId.name).to.equal('my-box/my-name');
+      expect(bitId.scope).to.equal('my-scope');
+      expect(bitId.version).to.equal('0.0.1');
+    });
+  });
+});

package/bit-id.ts

@@ -0,0 +1,314 @@
+import decamelize from 'decamelize';
+import * as path from 'path';
+import * as semver from 'semver';
+import { head, tail } from 'lodash';
+import { versionParser, isHash, isTag, LATEST_VERSION } from '@teambit/component-version';
+import isValidIdChunk from './utils/is-valid-id-chunk';
+import isValidScopeName from './utils/is-valid-scope-name';
+import { InvalidBitId, InvalidIdChunk, InvalidName, InvalidScopeName } from './exceptions';
+
+export type BitIdProps = {
+  scope?: string | null | undefined;
+  box?: string | undefined;
+  name: string;
+  version?: string | undefined;
+};
+
+type BitIdSerialized = { scope?: string; name: string; version?: string };
+
+export type BitIdStr = string;
+
+export const VERSION_DELIMITER = '@';
+
+export default class BitId {
+  readonly scope: string | null | undefined;
+  readonly box: string | undefined;
+  readonly name: string;
+  readonly version: string | undefined;
+
+  constructor({ scope, box, name, version }: BitIdProps) {
+    // don't validate the id parts using isValidIdChunk here. we instance this class tons of times
+    // and running regex so many times impact the performance
+    if (!name) throw new InvalidName(name);
+    this.scope = scope || null;
+    this.box = undefined;
+    this.name = box ? `${box}/${name}` : name;
+    this.version = version || undefined;
+    Object.freeze(this);
+  }
+
+  clone(): BitId {
+    return new BitId(this);
+  }
+
+  changeScope(newScope?: string | null | undefined): BitId {
+    return new BitId({ scope: newScope, name: this.name, version: this.version });
+  }
+
+  changeVersion(newVersion: string | undefined): BitId {
+    return new BitId({ scope: this.scope, name: this.name, version: newVersion });
+  }
+
+  isLocal(scopeName?: string): boolean {
+    return !this.scope || Boolean(scopeName && scopeName === this.scope);
+  }
+
+  getVersion() {
+    return versionParser(this.version);
+  }
+
+  hasVersion(): boolean {
+    return Boolean(this.version && this.version !== LATEST_VERSION);
+  }
+
+  hasScope(): boolean {
+    return Boolean(this.scope);
+  }
+
+  hasSameName(id: BitId): boolean {
+    return this.name === id.name;
+  }
+
+  hasSameScope(id: BitId): boolean {
+    if (this.hasScope() && id.hasScope()) return this.scope === id.scope;
+    if (!this.hasScope() && !id.hasScope()) return true;
+    return false; // one has scope but not the other
+  }
+
+  hasSameVersion(id: BitId): boolean {
+    if (this.hasVersion() && id.hasVersion()) return this.version === id.version;
+    if (!this.hasVersion() && !id.hasVersion()) return true;
+    return false; // one has version but not the other
+  }
+
+  toString(ignoreScope = false, ignoreVersion = false): BitIdStr {
+    const { name, version } = this;
+    const scope = this.scope;
+    const componentStr = ignoreScope || !scope ? name : [scope, name].join('/');
+    // when there is no scope and the version is latest, omit the version.
+    if (ignoreVersion || !this.hasVersion()) return componentStr;
+    return componentStr.concat(`${VERSION_DELIMITER}${version}`);
+  }
+
+  toStringWithoutScope(): BitIdStr {
+    return this.toString(true);
+  }
+
+  toStringWithoutVersion(): BitIdStr {
+    return this.toString(false, true);
+  }
+
+  toStringWithoutScopeAndVersion(): BitIdStr {
+    return this.toString(true, true);
+  }
+
+  isEqual(bitId: BitId): boolean {
+    return this.hasSameName(bitId) && this.hasSameScope(bitId) && this.hasSameVersion(bitId);
+  }
+
+  isEqualWithoutVersion(bitId: BitId): boolean {
+    return this.hasSameName(bitId) && this.hasSameScope(bitId);
+  }
+
+  isEqualWithoutScopeAndVersion(bitId: BitId): boolean {
+    return this.hasSameName(bitId);
+  }
+
+  serialize(): BitIdSerialized {
+    const obj = { scope: this.scope, name: this.name, version: this.version };
+    if (!this.hasVersion()) delete obj.version;
+    if (!this.hasScope()) delete obj.scope;
+    return obj as BitIdSerialized;
+  }
+
+  toFullPath(): string {
+    if (!this.scope || !this.version) {
+      throw new Error('BitId.toFullPath is unable to generate a path without a scope or a version');
+    }
+    return path.join(this.name, this.scope, this.version);
+  }
+
+  isVersionSnap() {
+    return !isTag(this.version);
+  }
+
+  /**
+   * examples:
+   * 1.0.0 => null
+   * 1.0.0-dev.1 => ['dev', 1]
+   * 1.0.0-dev.1.alpha.2 => ['dev', 1, 'alpha', 2]
+   * 1.0.0-0 => [0]
+   */
+  getVersionPreReleaseData(): null | readonly string[] {
+    if (!this.version) return null;
+    return semver.prerelease(this.version);
+  }
+
+  /**
+   * Get a string id and return a string without the version part
+   * @param {string} id
+   * @return {string} id - id without version
+   */
+  static getStringWithoutVersion(id: string): string {
+    const splitted = id.split(VERSION_DELIMITER);
+    let res = splitted[0];
+    // the delimiter is @. now with the new owner prefix
+    // many times the id starts with the @ sign as part of the @owner prefix
+    // do not treat this @ at the beginning as the version delimiter
+    if (id.startsWith(VERSION_DELIMITER)) {
+      res = `${VERSION_DELIMITER}${splitted[1]}`;
+    }
+    return res;
+  }
+
+  static getVersionOnlyFromString(id: string): string {
+    return id.split(VERSION_DELIMITER)[1];
+  }
+
+  static parse(id: BitIdStr, hasScope = true, version: string = LATEST_VERSION): BitId {
+    if (typeof id !== 'string') {
+      throw new TypeError(`BitId.parse expects to get "id" as a string, instead, got ${typeof id}`);
+    }
+
+    if (id.includes(VERSION_DELIMITER) && id.lastIndexOf(VERSION_DELIMITER) > 0) {
+      const [newId, newVersion] = id.split(VERSION_DELIMITER);
+      id = newId;
+      version = newVersion;
+    }
+
+    const getScopeAndName = () => {
+      if (hasScope) {
+        return BitId.getScopeAndName(id);
+      }
+
+      return {
+        scope: undefined,
+        name: id,
+      };
+    };
+    const { scope, name } = getScopeAndName();
+
+    if (!isValidIdChunk(name)) throw new InvalidName(name);
+    if (scope && !isValidScopeName(scope)) {
+      throw new InvalidScopeName(scope, id);
+    }
+
+    return new BitId({
+      scope,
+      name,
+      version,
+    });
+  }
+
+  static getScopeAndName(id: string) {
+    const delimiterIndex = id.indexOf('/');
+    if (delimiterIndex < 0) throw new InvalidBitId(id);
+    const scope = id.substring(0, delimiterIndex);
+    const name = id.substring(delimiterIndex + 1);
+    return {
+      scope,
+      name,
+    };
+  }
+
+  static parseObsolete(id: BitIdStr, version: string = LATEST_VERSION): BitId {
+    if (id.includes(VERSION_DELIMITER)) {
+      const [newId, newVersion] = id.split(VERSION_DELIMITER);
+      id = newId;
+      version = newVersion;
+    }
+
+    const idSplit = id.split('/');
+    if (idSplit.length === 3) {
+      const [scope, box, name] = idSplit;
+      if (!isValidIdChunk(name, false) || !isValidIdChunk(box, false) || !isValidScopeName(scope)) {
+        throw new InvalidIdChunk(`${scope}/${box}/${name}`);
+      }
+      // $FlowFixMe (in this case the realScopeName is not undefined)
+      return new BitId({
+        scope,
+        box,
+        name,
+        version,
+      });
+    }
+
+    if (idSplit.length === 2) {
+      const [box, name] = idSplit;
+      if (!isValidIdChunk(name, false) || !isValidIdChunk(box, false)) {
+        throw new InvalidIdChunk(`${box}/${name}`);
+      }
+      return new BitId({
+        box,
+        name,
+        version,
+      });
+    }
+
+    if (idSplit.length === 1) {
+      const [name] = idSplit;
+      if (!isValidIdChunk(name)) {
+        throw new InvalidIdChunk(name);
+      }
+      return new BitId({
+        name,
+        version,
+      });
+    }
+
+    throw new InvalidBitId(id);
+  }
+
+  /**
+   * before version 13.0.3 bitmap and component-dependencies ids were written as strings (e.g. scope/box/name@version)
+   * since that version the ids are written as objects ({ scope: scopeName, name: compName, version: 0.0.1 })
+   */
+  static parseBackwardCompatible(id: string | BitIdProps): BitId {
+    return typeof id === 'string' ? BitId.parseObsolete(id) : new BitId(id);
+  }
+
+  static getValidScopeName(scope: string) {
+    const suggestedName = scope.toLowerCase();
+    let cleanName = suggestedName
+      .split('')
+      .map((char) => {
+        if (/^[$\-_!.a-z0-9]+$/.test(char)) return char;
+        return '';
+      })
+      .join('');
+
+    // allow only one dot
+    const nameSplitByDot = cleanName.split('.');
+    if (nameSplitByDot.length > 1) {
+      cleanName = `${head(nameSplitByDot)}.${tail(nameSplitByDot).join('')}`;
+    }
+
+    if (!cleanName) {
+      // @todo: change it to BitError
+      throw new Error('scope name created by directory name have to contains at least one character or number');
+    }
+    return cleanName;
+  }
+
+  static getValidIdChunk(chunk: string): string {
+    if (!isValidIdChunk(chunk)) {
+      chunk = chunk.replace(/\./g, ''); // remove "."
+      chunk = chunk.replace(/ /g, '-'); // replace a space with a dash.
+      chunk = decamelize(chunk, '-');
+    }
+    return chunk;
+  }
+
+  static getValidBitId(box: string | undefined, name: string): BitId {
+    return new BitId({ name: BitId.getValidIdChunk(name), box: box ? BitId.getValidIdChunk(box) : undefined });
+  }
+
+  static isValidVersion(version: string): boolean {
+    // a version can be a tag (semver) or a snap (hash)
+    return isTag(version) || isHash(version);
+  }
+
+  static isValidSemver(version: string): boolean {
+    return Boolean(semver.valid(version));
+  }
+}