@teambit/harmony 0.2.11 → 0.3.0

package/extension/extension.ts

@@ -0,0 +1,138 @@
+import { ProviderFn } from '../types';
+import { Harmony } from '../harmony';
+import { ExtensionManifest } from './extension-manifest';
+import { ExtensionInstantiationException } from '../exceptions/extension-init-error';
+import { RuntimeDefinition } from '../runtimes';
+
+export type ExtensionProps = {
+  name: string;
+  // TODO: changes from any to something meaningful
+  dependencies: any[];
+  provider: ProviderFn;
+};
+
+/**
+ * harmony's extension definition. this can be used to define and extend `Harmony` applications.
+ */
+export class Extension {
+  constructor(
+    /**
+     * manifest of the extension.
+     */
+    readonly manifest: ExtensionManifest
+  ) {}
+
+  private _instance = null;
+
+  private _loaded = false;
+
+  /**
+   * returns the instance of the extension
+   */
+  get instance() {
+    return this._instance;
+  }
+
+  get name() {
+    const metadata = Reflect.getMetadata('harmony:name', this.manifest);
+    return metadata || this.manifest.id || this.manifest.name;
+  }
+
+  get id() {
+    return this.name;
+  }
+
+  get dependencies(): Extension[] {
+    const metadata = Reflect.getMetadata('harmony:dependencies', this.manifest);
+    return metadata || this.manifest.dependencies || [];
+  }
+
+  get provider() {
+    const metadata = Reflect.getMetadata('harmony:provider', this.manifest);
+    return metadata || this.manifest.provider;
+  }
+
+  get files() {
+    return this.manifest.files;
+  }
+
+  /**
+   * returns an indication of the extension already loaded (the provider run)
+   * We don't rely on the instance since an extension provider might return null
+   */
+  get loaded() {
+    return this._loaded;
+  }
+
+  toString(): string {
+    return JSON.stringify(this.name);
+  }
+
+  private buildSlotRegistries(slots: ((registerFn: () => void) => any)[], context: Harmony) {
+    return slots.map((slot) => {
+      return slot(() => {
+        return context.current;
+      });
+    });
+  }
+
+  get declareRuntime() {
+    return this.manifest.declareRuntime;
+  }
+
+  getRuntime(runtime: RuntimeDefinition) {
+    return this.manifest.getRuntime(runtime);
+  }
+
+  getSlots(extensionRuntime: any) {
+    if (extensionRuntime.slots && extensionRuntime.slots.length) {
+      return extensionRuntime.slots;
+    }
+
+    return this.manifest.slots || [];
+  }
+
+  getConfig(context: Harmony, extensionRuntime: any) {
+    const defaultConfig = extensionRuntime.defaultConfig || this.manifest.defaultConfig || {};
+    const config = context.config.get(this.name) || {};
+    return Object.assign({}, defaultConfig, config);
+  }
+
+  /**
+   * initiate Harmony in run-time.
+   */
+  async __run(dependencies: any[], context: Harmony, runtime: RuntimeDefinition) {
+    const name = this.name;
+    context.initExtension(name);
+    const extensionRuntime = this.getRuntime(runtime);
+    
+    if (!extensionRuntime) {
+      return undefined;
+    }
+
+    // @ts-ignore
+    const registries = this.buildSlotRegistries(this.getSlots(extensionRuntime), context);
+    const config = this.getConfig(context, extensionRuntime);
+
+    if (!this.loaded) {
+      if (extensionRuntime.provider) this._instance = await extensionRuntime.provider(dependencies, config, registries, context);
+      else {
+        try {
+          // @ts-ignore
+          this._instance = new extensionRuntime.manifest(...dependencies);
+        } catch(err) {
+          throw new ExtensionInstantiationException(err.toString());
+        }
+      };
+      // @ts-ignore adding the extension ID to the instance.
+      // this._instance.id = this.manifest.name;
+      // @ts-ignore adding the extension ID to the instance.
+      // this._instance.config = config;
+      this._loaded = true;
+      return this._instance;
+    }
+
+    context.endExtension();
+    return Promise.resolve(this.instance);
+  }
+}

package/extension/index.ts

@@ -0,0 +1,3 @@
+export { Extension, ExtensionProps } from './extension';
+export { ExtensionManifest } from './extension-manifest';
+export { ExtensionDecorator, register, hook, HookRegistry, provider, createHook } from './decorator';

package/extension-graph/extension-graph.ts

@@ -0,0 +1,151 @@
+import { Graph } from 'cleargraph';
+import { fromExtension, fromExtensions } from './from-extension';
+import { ExtensionManifest } from '../extension';
+import { Extension } from '../extension';
+import { RuntimeDefinition, Runtimes } from '../runtimes';
+import { RequireFn } from '../harmony';
+
+function getName(manifest: any) {
+  return Reflect.getMetadata('harmony:name', manifest) || manifest.id || manifest.name;
+}
+
+export type Edge = {
+  type: string,
+  runtime?: string
+};
+
+export default class DependencyGraph extends Graph<Extension, Edge> {
+  private cache = new Map<string, Extension>();
+
+  getRuntimeDependencies(aspect: Extension, runtime: RuntimeDefinition): Extension[] {
+    const dependencies = this.successors(aspect.name);
+    const runtimeDeps = this.successors(aspect.name, (edge) => {
+      if (!edge.runtime) return false;
+      return edge.runtime === runtime.name;
+    });
+    const runtimeManifest = aspect.getRuntime(runtime);
+    if (!runtimeManifest) return Array.from(dependencies.values());
+
+    if (runtimeDeps && runtimeDeps.size) return this.sortDeps(runtimeManifest.dependencies, Array.from(runtimeDeps.values()));
+    return this.sortDeps(runtimeManifest.dependencies, Array.from(dependencies.values()));
+  }
+
+  private sortDeps(originalDependencies: any[], targetDependencies: any[]) {
+    return targetDependencies.sort((a, b) => {
+      return originalDependencies.findIndex(item => item.id === a.id) - originalDependencies.findIndex(item => item.id === b.id);
+    });
+  }
+
+  byExecutionOrder() {
+    return this.toposort(true);
+  }
+
+  private async enrichRuntimeExtension(id: string, aspect: Extension, runtime: RuntimeDefinition, runtimes: Runtimes, requireFn: RequireFn) {
+    await requireFn(aspect, runtime);
+    const runtimeManifest = aspect.getRuntime(runtime)
+    if (!runtimeManifest) return;
+    const deps = runtimeManifest.dependencies;
+    if (!deps) return;
+    const promises = deps.map(async (dep: any) => {
+      if (!this.hasNode(dep.id)) {
+        this.add(dep);
+        if (dep.declareRuntime) {
+          runtimes.add(dep.declareRuntime);
+        }
+        
+        await requireFn(this.get(dep.id), runtime);
+        await this.enrichRuntimeExtension(dep.id, this.get(dep.id), runtime, runtimes, requireFn);
+      }
+
+      this.setEdge(id, dep.id, {
+        runtime: runtime.name,
+        type: 'runtime-dependency'
+      });
+    });
+
+    return Promise.all(promises);
+  }
+
+  async enrichRuntime(runtime: RuntimeDefinition, runtimes: Runtimes, requireFn: RequireFn) {
+    const promises = Array.from(this.nodes.entries()).map(async ([id, aspect]) => {
+      return this.enrichRuntimeExtension(id, aspect, runtime, runtimes, requireFn);
+    });
+
+    return Promise.all(promises);
+  }
+
+  add(manifest: ExtensionManifest) {
+    const { vertices, edges } = fromExtension(manifest);
+    this.setNodes(vertices);
+    this.setEdges(edges);
+
+    return this;
+  }
+
+  load(extensions: ExtensionManifest[]) {
+    const newExtensions = extensions.filter((extension) => {
+      if (!extension.id) return false;
+      return !this.get(extension.id);
+    });
+    const { vertices, edges } = fromExtensions(newExtensions);
+    // Only set new vertices
+    this.setNodes(vertices, false); // false because we don't want to override already-loaded extensions
+    this.setEdges(edges);
+
+    return this;
+  }
+
+  // :TODO refactor this asap
+  getExtension(manifest: ExtensionManifest) {
+    const id = getName(manifest);
+    const cachedVertex = this.cache.get(id);
+    if (cachedVertex) return cachedVertex;
+
+    const res = this.node(id);
+    if (res) {
+      this.cache.set(res.name, res);
+      return res;
+    }
+
+    return null;
+  }
+
+  get extensions(): ExtensionManifest[] {
+    return Array.from(this.nodes.values());
+  }
+
+  get aspects() {
+    return this.extensions;
+  }
+
+  get(id: string): any {
+    const cachedVertex = this.cache.get(id);
+    if (cachedVertex) return cachedVertex;
+
+    const res = this.node(id);
+    if (res) {
+      this.cache.set(res.name, res);
+      return res;
+    }
+
+    return null;
+  }
+
+  /**
+   * build Harmony from a single extension.
+   */  
+  static fromRoot(extension: ExtensionManifest) {
+    const { vertices, edges } = fromExtension(extension);
+
+    return new DependencyGraph(vertices, edges);
+  }
+
+  /**
+   * build Harmony from set of extensions
+   */
+  static from(extensions: ExtensionManifest[]) {
+    const { vertices, edges } = fromExtensions(extensions);
+
+    return new DependencyGraph(vertices, edges);
+  }
+}

package/extension-graph/from-extension.ts

@@ -0,0 +1,72 @@
+import { ExtensionManifest } from '../extension';
+import { extensionFactory } from '../factory';
+import ExtensionPotentialCircular from '../exceptions/extension-potential-circular';
+import { Extension } from '../extension';
+import { Edge } from './extension-graph';
+
+function getName(manifest: any) {
+  return Reflect.getMetadata('harmony:name', manifest) || manifest.id || manifest.name;
+}
+
+/**
+ * build vertices and edges from the given extension
+ */
+export function fromExtension(extension: ExtensionManifest) {
+  const vertices: { [id: string]: Extension } = {};
+  let edges: { sourceId: string; targetId: string; edge: Edge }[] = [];
+
+  function iterate(root: ExtensionManifest) {
+    const id = getName(root);
+    if (vertices[id]) return;
+
+    const instance = extensionFactory(root);
+    const validDeps = instance.dependencies.filter(dep => dep).map(dep => extensionFactory(dep));
+    if (instance.dependencies.length > validDeps.length) {
+      throw new ExtensionPotentialCircular(instance, validDeps);
+    }
+    vertices[id] = instance;
+    const newEdges = validDeps.map(dep => {
+      return {
+        sourceId: id,
+        targetId: dep.name,
+        edge: {
+          type: 'dependency'
+        }
+      };
+    });
+
+    edges = edges.concat(newEdges);
+
+    // @ts-ignore
+    instance.dependencies.forEach(dep => iterate(dep));
+  }
+
+  iterate(extension);
+
+  let vertexArray: { id: string; node: Extension }[] = [];
+  for (let [key, value] of Object.entries(vertices)) {
+    vertexArray.push({ id: key, node: value });
+  }
+
+  return {
+    vertices: vertexArray,
+    edges
+  };
+}
+
+/**
+ * build vertices and edges from the given list of extensions
+ */
+export function fromExtensions(extensions: ExtensionManifest[]) {
+  const perExtension = extensions.map(ext => fromExtension(ext));
+
+  return perExtension.reduce(
+    (acc, subgraph) => {
+      acc.edges = acc.edges.concat(subgraph.edges);
+      acc.vertices = acc.vertices.concat(subgraph.vertices);
+
+      return acc;
+    },
+    { vertices: [], edges: [] }
+  );
+}

package/extension-graph/index.ts

@@ -0,0 +1 @@
+export { default as DependencyGraph } from './extension-graph';

package/factory/extension-factory.ts

@@ -0,0 +1,8 @@
+import { ExtensionManifest } from '../extension/extension-manifest';
+import { Extension } from '../extension/extension';
+
+export function extensionFactory(manifest: ExtensionManifest) {
+  // to allow the use of `provide` as an alias to `provider` in ExtensionManifest
+  if (manifest.provide) manifest.provider = manifest.provide;
+  return new Extension(manifest);
+}

package/factory/index.ts

@@ -0,0 +1 @@
+export { extensionFactory } from './extension-factory';

package/fixtures/aspects/babel/babel.aspect.ts

@@ -0,0 +1,14 @@
+import type { BabelCLI } from './babel.cli';
+import { Aspect } from '../../../aspect';
+
+export type { BabelCLI };
+
+export const BabelAspect = Aspect.create({
+  id: '@teambit/babel',
+  dependencies: [],
+  files: [
+    require.resolve('./babel.cli')
+  ]
+});
+
+export default BabelAspect;

package/fixtures/aspects/babel/babel.cli.ts

@@ -0,0 +1,16 @@
+import { BabelAspect } from './babel.aspect';
+import { CLIRuntime } from '../react/react.aspect';
+
+export class BabelCLI {
+  compile() {
+    console.log('compiled!');
+  }
+
+  static runtime = CLIRuntime;
+
+  static async provider() {
+    return new BabelCLI();
+  }
+}
+
+BabelAspect.addRuntime(BabelCLI);

package/fixtures/aspects/react/react.aspect.ts

@@ -0,0 +1,22 @@
+import { BabelAspect } from '../babel/babel.aspect';
+import { Aspect } from '../../../aspect';
+import { Slot } from '../../../slots';
+import { RuntimeDefinition } from '../../../runtimes';
+import { UIAspect } from '../ui/ui.aspect';
+
+export type Config = {};
+
+export const CLIRuntime = RuntimeDefinition.create({ name: 'cli' })
+
+export const ReactAspect = Aspect.create({
+  id: '@teambit/react',
+  dependencies: [UIAspect],
+  defaultConfig: {},
+  declareRuntime: CLIRuntime,
+  files: [
+    require.resolve('./react.cli'),
+    require.resolve('./react.ui')
+  ]
+});
+
+export default ReactAspect;

package/fixtures/aspects/react/react.cli.ts

@@ -0,0 +1,26 @@
+import ReactAspect, { CLIRuntime } from './react.aspect';
+import BabelAspect, { BabelCLI } from '../babel/babel.aspect';
+import { Slot, SlotRegistry } from '../../../slots';
+
+export class ReactCLI {
+  constructor(
+    private babel: BabelCLI
+  ) {}
+
+  static runtime = CLIRuntime;
+
+  hello() {
+    return this.babel.compile();
+  }
+
+  static dependencies = [BabelAspect];
+
+  static slots = [Slot.withType<string>()];
+
+  static async provider([babelCli]: [BabelCLI], config: {}, [stringSlot]: [SlotRegistry<string>]) {
+    stringSlot.register('hi there');
+    return new ReactCLI(babelCli);
+  }
+}
+
+ReactAspect.addRuntime(ReactCLI);

package/fixtures/aspects/react/react.ui.ts

@@ -0,0 +1,16 @@
+import ReactAspect from './react.aspect';
+import { UIRuntime } from '../ui/ui.aspect';
+
+export class ReactUI {
+  static runtime = UIRuntime;
+
+  render() {
+    return 'rendering something!';
+  }
+
+  static async provider() {
+    return new ReactUI();
+  } 
+}
+
+ReactAspect.addRuntime(ReactUI);

package/fixtures/aspects/ui/ui.aspect.ts

@@ -0,0 +1,13 @@
+import { Aspect } from '../../../aspect';
+import { RuntimeDefinition } from '../../../runtimes';
+
+export const UIRuntime = RuntimeDefinition.create({ name: 'ui' });
+
+export const UIAspect = Aspect.create({
+  id: '@teambit/ui',
+  dependencies: [],
+  declareRuntime: UIRuntime,
+  files: [
+    require.resolve('./ui.ui')
+  ]
+});

package/fixtures/aspects/ui/ui.ui.ts

@@ -0,0 +1,11 @@
+import { UIAspect, UIRuntime } from './ui.aspect';
+
+export class UiUI {
+  static runtime = UIRuntime;
+
+  static async provider() {
+    return new UiUI();
+  }
+}
+
+UIAspect.addRuntime(UiUI);

package/fixtures/babel/babel.extension.ts

@@ -0,0 +1,20 @@
+import { Extension, provider } from '../..';
+import { BaseCompiler } from '../base-compiler';
+
+class Mock {
+
+}
+
+// @Extension({
+  // dependencies: [BaseCompiler]
+// })
+export class Babel {
+  constructor(
+    private mock?: Mock
+  ) {}
+
+  // @provider()
+  async provide([baseCompiler]: [BaseCompiler]) {
+    return new Babel();
+  }
+}

package/fixtures/base-compiler/base-compiler.extension.ts

@@ -0,0 +1,31 @@
+import { Extension } from "../..";
+import { CLI, Command } from '../cli';
+
+// @Extension()
+export class BaseCompiler {
+  constructor(
+    private cli: CLI
+  ) {}
+
+  // @Config()
+  config() {
+    return {
+      cjs: 'blue/green'
+    };
+  }
+
+  // @Command
+  main() {
+    return {
+      synopsis: 'compile <id>',
+      report: () => {
+        return 'compiled in 0.1 secs';
+      }
+    };
+  }
+
+  compile() {
+    this.cli.run();
+    return 'hello world';
+  }
+}

package/fixtures/base-compiler/index.ts

@@ -0,0 +1 @@
+export { BaseCompiler } from './base-compiler.extension';

package/fixtures/cli/cli.extension.ts

@@ -0,0 +1,25 @@
+import { Extension, createHook } from '../..';
+import { HookRegistry, hook } from '../..';
+
+/**
+ * hook for registering new CLI commands.
+ */
+export const Command = createHook();
+
+export type CommandDefinition = {
+  synopsis: string,
+  report: string
+};
+
+// @Extension()
+export class CLI {
+  /**
+   * registry for the commands hook
+   */
+  private commands = HookRegistry.of<CommandDefinition>(Command);
+
+  run() {
+    const commands = this.commands.list();
+    return commands;
+  }
+}

package/fixtures/cli/command.ts

@@ -0,0 +1,6 @@
+interface Command {
+  command(): {
+    synopsis: string,
+    run: () => Promise<any>
+  }
+}

package/fixtures/cli/index.ts

@@ -0,0 +1 @@
+export * from './cli.extension';

package/fixtures/typescript/typescript.ts

@@ -0,0 +1,20 @@
+import { Extension } from '../..';
+import { BaseCompiler } from '../base-compiler';
+
+// @Extension({
+//   name: 'typescript',
+//   dependencies: [BaseCompiler]
+// })
+export class TypeScript {
+  constructor(
+    private compiler: string
+  ) {}
+
+  compile() {
+    return this.compiler;
+  }
+
+  static async provider([baseCompiler]: [BaseCompiler]) {
+    return new TypeScript(baseCompiler.compile());
+  }
+}

package/harmony-config/config-reader.ts

@@ -0,0 +1,17 @@
+import { parse } from 'comment-json';
+import { readFileSync, existsSync } from 'fs-extra';
+import { ReadConfigError } from './exceptions/read-config-error';
+
+export function readConfigFile(path: string, mustExist = true) {
+  if (!mustExist && !existsSync(path)) {
+    return {};
+  }
+
+  try {
+    const json = parse(readFileSync(path, 'utf8'));
+    delete json.$schema;
+    return json;
+  } catch (err) {
+    throw new ReadConfigError(path, err);
+  }
+}

package/harmony-config/exceptions/index.ts

@@ -0,0 +1 @@
+export { ReadConfigError } from './read-config-error';

package/harmony-config/exceptions/read-config-error.ts

@@ -0,0 +1,9 @@
+export class ReadConfigError extends Error {
+  constructor(path: string, private err: Error) {
+    super(`failed to read config from path: ${path}`);
+  }
+
+  get stack() {
+    return this.err.stack;
+  }
+}