@teambit/objects 0.0.0-00042bc99514ea12d897f81bcd0181e2b034c615

package/models/scopeMeta.ts

@@ -0,0 +1,58 @@
+import { getStringifyArgs } from '@teambit/legacy.utils';
+import { BitObject } from '../objects';
+import type Ref from '../objects/ref';
+
+type ScopeMetaProps = {
+  name: string;
+  license: string;
+};
+
+// TODO: fix parse
+export default class ScopeMeta extends BitObject {
+  license: string | null | undefined;
+  name: string;
+
+  constructor(props: ScopeMetaProps) {
+    super();
+    this.license = props.license;
+    this.name = props.name;
+  }
+
+  toObject(): Record<string, any> {
+    return {
+      license: this.license,
+      name: this.name,
+    };
+  }
+
+  toString(pretty: boolean): string {
+    const args = getStringifyArgs(pretty);
+    return JSON.stringify(this.toObject(), ...args);
+  }
+
+  id(): string {
+    return this.name;
+  }
+
+  toBuffer(pretty): Buffer {
+    return Buffer.from(this.toString(pretty));
+  }
+
+  static fromScopeName(name: string): Ref {
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    return ScopeMeta.fromObject({ name }).hash();
+  }
+
+  static parse(propsStr: string | Buffer): ScopeMeta {
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    return this.fromObject(JSON.parse(propsStr));
+  }
+
+  static fromObject(props: ScopeMetaProps): ScopeMeta {
+    return new ScopeMeta(props);
+  }
+
+  static from(props: ScopeMetaProps): ScopeMeta {
+    return ScopeMeta.fromObject(props);
+  }
+}

package/models/source.ts

@@ -0,0 +1,31 @@
+import { BitObject } from '../objects';
+
+// TODO: fix .parse
+export default class Source extends BitObject {
+  contents: Buffer;
+
+  constructor(contents: Buffer) {
+    super();
+    this.contents = contents;
+  }
+
+  id() {
+    return this.contents;
+  }
+
+  toBuffer() {
+    return this.contents;
+  }
+
+  toString() {
+    return this.contents.toString();
+  }
+
+  static parse(contents: Buffer): Source {
+    return new Source(contents);
+  }
+
+  static from(buffer: Buffer): Source {
+    return new Source(buffer);
+  }
+}

package/models/symlink.ts

@@ -0,0 +1,66 @@
+import { ComponentID } from '@teambit/component-id';
+import { BitId } from '@teambit/legacy-bit-id';
+import { getStringifyArgs } from '@teambit/legacy.utils';
+import { BitObject } from '../objects';
+
+export type SymlinkProp = {
+  scope: string;
+  name: string;
+  realScope: string;
+};
+
+/**
+ * @deprecated
+ * this is not used since component-schema 2.0.0, where the component-id is always the full id.
+ */
+export default class Symlink extends BitObject {
+  scope: string;
+  name: string;
+  realScope: string;
+
+  constructor(props: SymlinkProp) {
+    super();
+    this.scope = props.scope;
+    this.name = props.name;
+    this.realScope = props.realScope;
+  }
+
+  id(): string {
+    return this.name;
+  }
+
+  getRealComponentId(): ComponentID {
+    return ComponentID.fromObject({ scope: this.realScope, name: this.name });
+  }
+
+  toComponentId(): ComponentID {
+    return this.getRealComponentId();
+  }
+
+  static parse(contents: Buffer): Symlink {
+    const rawContent = JSON.parse(contents.toString());
+    if (rawContent.box) rawContent.name = `${rawContent.box}/${rawContent.name}`;
+    return Symlink.from(rawContent);
+  }
+
+  toObject() {
+    return {
+      scope: this.scope,
+      name: this.name,
+      realScope: this.realScope,
+    };
+  }
+
+  toBitId(): BitId {
+    return new BitId({ name: this.name });
+  }
+
+  toBuffer(pretty?: boolean) {
+    const args = getStringifyArgs(pretty);
+    return Buffer.from(JSON.stringify(this.toObject(), ...args));
+  }
+
+  static from(props: SymlinkProp) {
+    return new Symlink(props);
+  }
+}

package/models/version-history.ts

@@ -0,0 +1,283 @@
+import { Graph, Edge, Node } from '@teambit/graph.cleargraph';
+import { ComponentID } from '@teambit/component-id';
+import { BitError } from '@teambit/bit-error';
+import { compact, difference, uniqBy } from 'lodash';
+import { getStringifyArgs } from '@teambit/legacy.utils';
+import Ref from '../objects/ref';
+import { BitObject } from '../objects';
+import type Version from './version';
+import { getVersionParentsFromVersion } from '@teambit/component.snap-distance';
+import type ModelComponent from './model-component';
+
+export type VersionParents = {
+  hash: Ref;
+  parents: Ref[];
+  unrelated?: Ref;
+  squashed?: Ref[];
+};
+
+export type VersionHistoryGraph = Graph<string | HashMetadata, string>;
+
+type VersionHistoryProps = {
+  name: string;
+  scope: string;
+  versions: VersionParents[];
+  graphCompleteRefs?: string[];
+};
+
+type HashMetadata = {
+  tag?: string;
+  pointers?: string[];
+};
+
+export default class VersionHistory extends BitObject {
+  name: string;
+  scope: string;
+  private versionsObj: { [hash: string]: VersionParents };
+  graphCompleteRefs: string[];
+  hasChanged = false; // whether the version history has changed since the last persist
+  constructor(props: VersionHistoryProps) {
+    super();
+    this.name = props.name;
+    this.scope = props.scope;
+    this.versionsObj = this.versionParentsToObject(props.versions);
+    this.graphCompleteRefs = props.graphCompleteRefs || [];
+  }
+
+  get versions() {
+    return Object.values(this.versionsObj);
+  }
+
+  private versionParentsToObject(versions: VersionParents[]) {
+    return versions.reduce((acc, version) => {
+      acc[version.hash.hash] = version;
+      return acc;
+    }, {});
+  }
+
+  id() {
+    return `${this.scope}/${this.name}:${VersionHistory.name}`;
+  }
+
+  static fromId(name: string, scope: string) {
+    return new VersionHistory({ scope, name, versions: [] });
+  }
+
+  toObject(): Record<string, any> {
+    return {
+      name: this.name,
+      scope: this.scope,
+      versions: this.versions.map((v) => ({
+        hash: v.hash.toString(),
+        parents: v.parents.map((p) => p.toString()),
+        unrelated: v.unrelated?.toString(),
+        squashed: v.squashed ? v.squashed.map((p) => p.toString()) : undefined,
+      })),
+      graphCompleteRefs: this.graphCompleteRefs,
+    };
+  }
+
+  toString(pretty: boolean): string {
+    const args = getStringifyArgs(pretty);
+    return JSON.stringify(this.toObject(), ...args);
+  }
+
+  toBuffer(pretty): Buffer {
+    return Buffer.from(this.toString(pretty));
+  }
+
+  getVersionData(ref: Ref): VersionParents | undefined {
+    return this.versionsObj[ref.toString()];
+  }
+
+  hasHash(ref: Ref) {
+    return Boolean(this.getVersionData(ref));
+  }
+
+  addFromVersionsObjects(versions: Version[]) {
+    versions.forEach((version) => {
+      const exists = this.getVersionData(version.hash());
+      if (exists) {
+        // just in case the parents got updated as a result of a merge/squash
+        exists.parents = version.parents;
+        exists.unrelated = version.unrelated?.head;
+        exists.squashed = version.squashed?.previousParents;
+      } else {
+        const versionData = getVersionParentsFromVersion(version);
+        this.versionsObj[version.hash().hash] = versionData;
+      }
+    });
+  }
+
+  isEmpty() {
+    return !this.versions.length;
+  }
+
+  getAllHashesFrom(start: Ref): { found?: string[]; missing?: string[] } {
+    const item = this.getVersionData(start);
+    if (!item) return { missing: [start.toString()] };
+    const hashSet = new Set<string>();
+    const allHashes: string[] = [];
+    const missing: string[] = [];
+
+    // Use iterative approach with a stack to avoid stack overflow on deep histories
+    const stack: VersionParents[] = [item];
+    hashSet.add(item.hash.toString());
+
+    while (stack.length > 0) {
+      const ver = stack.pop()!;
+      const verHash = ver.hash.toString();
+      allHashes.push(verHash);
+
+      for (const parent of ver.parents) {
+        const parentHash = parent.toString();
+        if (hashSet.has(parentHash)) continue;
+        const parentVer = this.getVersionData(parent);
+        if (!parentVer) {
+          missing.push(parentHash);
+          continue;
+        }
+        // Mark as processed before pushing to prevent duplicate stack entries
+        hashSet.add(parentHash);
+        stack.push(parentVer);
+      }
+    }
+
+    return { found: allHashes, missing };
+  }
+
+  isRefPartOfHistory(startFrom: Ref, searchFor: Ref) {
+    const { found } = this.getAllHashesFrom(startFrom);
+    return found?.includes(searchFor.toString());
+  }
+
+  isGraphCompleteSince(ref: Ref) {
+    if (this.graphCompleteRefs.includes(ref.toString())) return true;
+    const { missing } = this.getAllHashesFrom(ref);
+    const isComplete = !missing || !missing.length;
+    if (isComplete) {
+      this.graphCompleteRefs.push(ref.toString());
+      this.hasChanged = true;
+    }
+    return isComplete;
+  }
+
+  getAllHashesAsString(): string[] {
+    return Object.keys(this.versionsObj);
+  }
+
+  merge(versionHistory: VersionHistory) {
+    const existingHashes = this.getAllHashesAsString();
+    const incomingHashes = versionHistory.getAllHashesAsString();
+    const hashesInExistingOnly = difference(existingHashes, incomingHashes);
+    const versionsDataOnExistingOnly = this.versions.filter((v) => hashesInExistingOnly.includes(v.hash.toString()));
+    const newVersions = [...versionHistory.versions, ...versionsDataOnExistingOnly];
+    this.versionsObj = this.versionParentsToObject(newVersions);
+  }
+
+  getAncestor(numOfGenerationsToGoBack: number, ref: Ref): Ref {
+    const errorMsg = `unable to get an older parent of ${this.compId.toString()}`;
+    const versionData = this.getVersionData(ref);
+    if (!versionData)
+      throw new BitError(`${errorMsg}, version "${ref.toString()}" was not found in the version history`);
+    if (numOfGenerationsToGoBack === 0) return versionData.hash;
+    if (!versionData.parents.length) throw new BitError(`${errorMsg}, version "${ref.toString()}" has no parents`);
+    const parent = versionData.parents[0];
+    return this.getAncestor(numOfGenerationsToGoBack - 1, parent);
+  }
+
+  getGraph(
+    modelComponent?: ModelComponent,
+    laneHeads?: { [hash: string]: string[] },
+    shortHash = false,
+    limitVersions?: number
+  ): VersionHistoryGraph {
+    const refToStr = (ref: Ref) => (shortHash ? ref.toShortString() : ref.toString());
+    const graph = new Graph<string | HashMetadata, string>();
+    const allVersions = limitVersions ? [...this.versions].slice(-limitVersions) : this.versions;
+    const allHashes = allVersions
+      .map((v) => compact([v.hash, ...v.parents, ...(v.squashed || []), v.unrelated]))
+      .flat();
+
+    const allHashesUniq = uniqBy(allHashes, 'hash');
+
+    const getMetadata = (ref: Ref): HashMetadata | undefined => {
+      if (!modelComponent || !laneHeads) return undefined;
+      const tag = modelComponent.getTagOfRefIfExists(ref);
+      const pointers = laneHeads[ref.toString()];
+      return { tag, pointers };
+    };
+    const nodes = allHashesUniq.map((v) => new Node(refToStr(v), getMetadata(v) || refToStr(v)));
+
+    const edges = allVersions
+      .map((v) => {
+        const verEdges = v.parents.map((p) => new Edge(refToStr(v.hash), refToStr(p), 'parent'));
+        if (v.unrelated) verEdges.push(new Edge(refToStr(v.hash), refToStr(v.unrelated), 'unrelated'));
+        if (v.squashed) {
+          const squashed = v.squashed.filter((s) => !v.parents.find((p) => p.isEqual(s)));
+          squashed.map((p) => verEdges.push(new Edge(refToStr(v.hash), refToStr(p), 'squashed')));
+        }
+        return verEdges;
+      })
+      .flat();
+    graph.setNodes(nodes);
+    graph.setEdges(edges);
+    return graph;
+  }
+
+  get compId() {
+    return ComponentID.fromObject({ scope: this.scope, name: this.name });
+  }
+
+  static create(name: string, scope: string, versions: VersionParents[]) {
+    return new VersionHistory({
+      name,
+      scope,
+      versions,
+    });
+  }
+
+  static parse(contents: string): VersionHistory {
+    const parsed = JSON.parse(contents);
+    const props: VersionHistoryProps = {
+      name: parsed.name,
+      scope: parsed.scope,
+      versions: parsed.versions.map((ver) => ({
+        hash: Ref.from(ver.hash),
+        parents: ver.parents.map((p) => Ref.from(p)),
+        unrelated: ver.unrelated ? Ref.from(ver.unrelated) : undefined,
+        squashed: ver.squashed ? ver.squashed.map((p) => Ref.from(p)) : undefined,
+      })),
+      graphCompleteRefs: parsed.graphCompleteRefs,
+    };
+    return new VersionHistory(props);
+  }
+}
+
+export function versionParentsToGraph(versions: VersionParents[]): Graph<string, string> {
+  const refToStr = (ref: Ref) => ref.toString();
+  const graph = new Graph<string, string>();
+  const allHashes = uniqBy(
+    versions
+      .map((v) => {
+        return compact([v.hash, ...v.parents, ...(v.squashed || []), v.unrelated]);
+      })
+      .flat(),
+    'hash'
+  );
+  const nodes = allHashes.map((v) => new Node(refToStr(v), refToStr(v)));
+  const edges = versions
+    .map((v) => {
+      const verEdges = v.parents.map((p) => new Edge(refToStr(v.hash), refToStr(p), 'parent'));
+      if (v.unrelated) verEdges.push(new Edge(refToStr(v.hash), refToStr(v.unrelated), 'unrelated'));
+      if (v.squashed) {
+        const squashed = v.squashed.filter((s) => !v.parents.find((p) => p.isEqual(s)));
+        squashed.map((p) => verEdges.push(new Edge(refToStr(v.hash), refToStr(p), 'squashed')));
+      }
+      return verEdges;
+    })
+    .flat();
+  graph.setNodes(nodes);
+  graph.setEdges(edges);
+  return graph;
+}