@featurevisor/core 0.53.5 → 0.54.0

package/src/config/parsers.ts

@@ -0,0 +1,40 @@
+import * as YAML from "js-yaml";
+
+/**
+ * If we want to add more built-in parsers,
+ * add them to this object with new file extension as the key,
+ * and a function that takes file content as string and returns parsed object as the value.
+ */
+export const parsers: { [key: string]: CustomParser } = {
+  // YAML
+  yml: {
+    extension: "yml",
+    parse: function <T>(content: string): T {
+      return YAML.load(content) as T;
+    },
+    stringify: function (content: any) {
+      return YAML.dump(content);
+    },
+  },
+
+  // JSON
+  json: {
+    extension: "json",
+    parse: function <T>(content: string): T {
+      return JSON.parse(content) as T;
+    },
+    stringify: function (content: any) {
+      return JSON.stringify(content, null, 2);
+    },
+  },
+};
+
+export type BuiltInParser = keyof typeof parsers; // keys of parsers object
+
+export interface CustomParser {
+  extension: string;
+  parse: <T>(content: string) => T;
+  stringify: (content: any) => string;
+}
+
+export type Parser = BuiltInParser | CustomParser;

package/src/{config.ts → config/projectConfig.ts}

@@ -2,7 +2,8 @@ import * as path from "path";
 
 import { BucketBy } from "@featurevisor/types";
 
-import { Parser } from "./datasource/parsers";
+import { Parser, parsers } from "./parsers";
+import { FilesystemAdapter } from "../datasource/filesystemAdapter";
 
 export const FEATURES_DIRECTORY_NAME = "features";
 export const SEGMENTS_DIRECTORY_NAME = "segments";
@@ -42,6 +43,7 @@ export interface ProjectConfig {
   prettyState: boolean;
   prettyDatafile: boolean;
   siteExportDirectoryPath: string;
+  adapter: any; // @TODO: type this properly later
 }
 
 // rootDirectoryPath: path to the root directory of the project (without ending with a slash)
@@ -66,20 +68,33 @@ export function getProjectConfig(rootDirectoryPath: string): ProjectConfig {
     prettyDatafile: DEFAULT_PRETTY_DATAFILE,
 
     siteExportDirectoryPath: path.join(rootDirectoryPath, SITE_EXPORT_DIRECTORY_NAME),
+
+    adapter: FilesystemAdapter,
   };
 
   const configModulePath = path.join(rootDirectoryPath, CONFIG_MODULE_NAME);
   const customConfig = require(configModulePath);
 
-  const finalConfig = {};
+  const mergedConfig = {};
 
   Object.keys(baseConfig).forEach((key) => {
-    finalConfig[key] = customConfig[key] || baseConfig[key];
+    mergedConfig[key] = customConfig[key] || baseConfig[key];
 
-    if (key.endsWith("Path") && finalConfig[key].indexOf(ROOT_DIR_PLACEHOLDER) !== -1) {
-      finalConfig[key] = finalConfig[key].replace(ROOT_DIR_PLACEHOLDER, rootDirectoryPath);
+    if (key.endsWith("Path") && mergedConfig[key].indexOf(ROOT_DIR_PLACEHOLDER) !== -1) {
+      mergedConfig[key] = mergedConfig[key].replace(ROOT_DIR_PLACEHOLDER, rootDirectoryPath);
     }
   });
 
+  const finalConfig = mergedConfig as ProjectConfig;
+
+  if (typeof finalConfig.parser === "string") {
+    const allowedParsers = Object.keys(parsers);
+    if (allowedParsers.indexOf(finalConfig.parser) === -1) {
+      throw new Error(`Invalid parser: ${finalConfig.parser}`);
+    }
+
+    finalConfig.parser = parsers[finalConfig.parser];
+  }
+
   return finalConfig as ProjectConfig;
 }

package/src/datasource/adapter.ts

@@ -0,0 +1,15 @@
+import { EnvironmentKey, ExistingState } from "@featurevisor/types";
+
+export type EntityType = "feature" | "group" | "segment" | "attribute" | "test";
+
+export abstract class Adapter {
+  // entities
+  abstract listEntities(entityType: EntityType): Promise<string[]>;
+  abstract entityExists(entityType: EntityType, entityKey: string): Promise<boolean>;
+  abstract readEntity(entityType: EntityType, entityKey: string): Promise<string>;
+  abstract parseEntity<T>(entityType: EntityType, entityKey: string): Promise<T>;
+
+  // state
+  abstract readState(environment: EnvironmentKey): Promise<ExistingState>;
+  abstract writeState(environment: EnvironmentKey, existingState: ExistingState): Promise<void>;
+}

package/src/datasource/datasource.ts

@@ -1,8 +1,3 @@
-import * as path from "path";
-import * as fs from "fs";
-
-import * as mkdirp from "mkdirp";
-
 import {
   ParsedFeature,
   Segment,
@@ -12,137 +7,35 @@ import {
   Test,
   EnvironmentKey,
   ExistingState,
+  SegmentKey,
+  AttributeKey,
 } from "@featurevisor/types";
 
-import { ProjectConfig } from "../config";
-import { parsers } from "./parsers";
-
-export type EntityType = "feature" | "group" | "segment" | "attribute" | "test";
+import { ProjectConfig, CustomParser } from "../config";
 
-export function getExistingStateFilePath(
-  projectConfig: ProjectConfig,
-  environment: EnvironmentKey,
-): string {
-  return path.join(projectConfig.stateDirectoryPath, `existing-state-${environment}.json`);
-}
+import { Adapter } from "./adapter";
 
 export class Datasource {
-  private extension;
-  private parse;
+  private adapter: Adapter;
 
   constructor(private config: ProjectConfig) {
-    if (typeof config.parser === "string") {
-      // built-in parsers
-      if (typeof parsers[config.parser] !== "function") {
-        throw new Error(`Invalid parser: ${config.parser}`);
-      }
-
-      this.extension = config.parser;
-      this.parse = parsers[config.parser];
-    } else if (typeof config.parser === "object") {
-      // custom parser
-      if (typeof config.parser.extension !== "string") {
-        throw new Error(`Invalid parser extension: ${config.parser.extension}`);
-      }
-
-      if (typeof config.parser.parse !== "function") {
-        throw new Error(`Invalid parser parse function: ${config.parser.parse}`);
-      }
-
-      this.extension = config.parser.extension;
-      this.parse = config.parser.parse;
-    } else {
-      throw new Error(`Invalid parser: ${config.parser}`);
-    }
+    this.adapter = new config.adapter(config);
   }
 
+  // @TODO: only site generator needs it, find a way to get it out of here later
   getExtension() {
-    return this.extension;
-  }
-
-  /**
-   * Common methods for entities
-   */
-  async listEntities(entityType: EntityType): Promise<string[]> {
-    const directoryPath = this.getEntityDirectoryPath(entityType);
-
-    if (!fs.existsSync(directoryPath)) {
-      return [];
-    }
-
-    return fs
-      .readdirSync(directoryPath)
-      .filter((fileName) => fileName.endsWith(`.${this.extension}`))
-      .map((fileName) => fileName.replace(`.${this.extension}`, ""));
-  }
-
-  getEntityDirectoryPath(entityType: EntityType): string {
-    if (entityType === "feature") {
-      return this.config.featuresDirectoryPath;
-    } else if (entityType === "group") {
-      return this.config.groupsDirectoryPath;
-    } else if (entityType === "segment") {
-      return this.config.segmentsDirectoryPath;
-    } else if (entityType === "test") {
-      return this.config.testsDirectoryPath;
-    }
-
-    return this.config.attributesDirectoryPath;
-  }
-
-  getEntityPath(entityType: EntityType, entityKey: string): string {
-    const basePath = this.getEntityDirectoryPath(entityType);
-
-    return path.join(basePath, `${entityKey}.${this.extension}`);
-  }
-
-  async entityExists(entityType: EntityType, entityKey: string): Promise<boolean> {
-    const entityPath = this.getEntityPath(entityType, entityKey);
-
-    return fs.existsSync(entityPath);
-  }
-
-  async readEntity(entityType: EntityType, entityKey: string): Promise<string> {
-    const filePath = this.getEntityPath(entityType, entityKey);
-
-    return fs.readFileSync(filePath, "utf8");
-  }
-
-  async parseEntity<T>(entityType: EntityType, entityKey: string): Promise<T> {
-    const entityContent = await this.readEntity(entityType, entityKey);
-
-    return this.parse(entityContent) as T;
+    return (this.config.parser as CustomParser).extension;
   }
 
   /**
    * State
    */
   async readState(environment: EnvironmentKey): Promise<ExistingState> {
-    const filePath = getExistingStateFilePath(this.config, environment);
-
-    if (!fs.existsSync(filePath)) {
-      return {
-        features: {},
-      };
-    }
-
-    return require(filePath);
+    return this.adapter.readState(environment);
   }
 
   async writeState(environment: EnvironmentKey, existingState: ExistingState) {
-    const filePath = getExistingStateFilePath(this.config, environment);
-
-    if (!fs.existsSync(this.config.stateDirectoryPath)) {
-      mkdirp.sync(this.config.stateDirectoryPath);
-    }
-    fs.writeFileSync(
-      filePath,
-      this.config.prettyState
-        ? JSON.stringify(existingState, null, 2)
-        : JSON.stringify(existingState),
-    );
-
-    fs.writeFileSync(filePath, JSON.stringify(existingState, null, 2));
+    return this.adapter.writeState(environment, existingState);
   }
 
   /**
@@ -151,11 +44,15 @@ export class Datasource {
 
   // features
   async listFeatures() {
-    return await this.listEntities("feature");
+    return await this.adapter.listEntities("feature");
+  }
+
+  featureExists(featureKey: FeatureKey) {
+    return this.adapter.entityExists("feature", featureKey);
   }
 
-  readFeature(featureKey: string) {
-    return this.parseEntity<ParsedFeature>("feature", featureKey);
+  readFeature(featureKey: FeatureKey) {
+    return this.adapter.parseEntity<ParsedFeature>("feature", featureKey);
   }
 
   async getRequiredFeaturesChain(
@@ -164,7 +61,7 @@ export class Datasource {
   ): Promise<Set<FeatureKey>> {
     chain.add(featureKey);
 
-    if (!this.entityExists("feature", featureKey)) {
+    if (!this.adapter.entityExists("feature", featureKey)) {
       throw new Error(`Feature not found: ${featureKey}`);
     }
 
@@ -189,37 +86,53 @@ export class Datasource {
 
   // segments
   listSegments() {
-    return this.listEntities("segment");
+    return this.adapter.listEntities("segment");
+  }
+
+  segmentExists(segmentKey: SegmentKey) {
+    return this.adapter.entityExists("segment", segmentKey);
   }
 
-  readSegment(segmentKey: string) {
-    return this.parseEntity<Segment>("segment", segmentKey);
+  readSegment(segmentKey: SegmentKey) {
+    return this.adapter.parseEntity<Segment>("segment", segmentKey);
   }
 
   // attributes
   listAttributes() {
-    return this.listEntities("attribute");
+    return this.adapter.listEntities("attribute");
   }
 
-  readAttribute(attributeKey: string) {
-    return this.parseEntity<Attribute>("attribute", attributeKey);
+  attributeExists(attributeKey: AttributeKey) {
+    return this.adapter.entityExists("attribute", attributeKey);
+  }
+
+  readAttribute(attributeKey: AttributeKey) {
+    return this.adapter.parseEntity<Attribute>("attribute", attributeKey);
   }
 
   // groups
   async listGroups() {
-    return this.listEntities("group");
+    return this.adapter.listEntities("group");
+  }
+
+  groupExists(groupKey: string) {
+    return this.adapter.entityExists("group", groupKey);
   }
 
   readGroup(groupKey: string) {
-    return this.parseEntity<Group>("group", groupKey);
+    return this.adapter.parseEntity<Group>("group", groupKey);
   }
 
   // tests
   listTests() {
-    return this.listEntities("test");
+    return this.adapter.listEntities("test");
   }
 
   readTest(testKey: string) {
-    return this.parseEntity<Test>("test", testKey);
+    return this.adapter.parseEntity<Test>("test", testKey);
+  }
+
+  getTestSpecName(testKey: string) {
+    return `${testKey}.${this.getExtension()}`;
   }
 }

package/src/datasource/filesystemAdapter.ts

@@ -0,0 +1,108 @@
+import * as fs from "fs";
+import * as path from "path";
+
+import * as mkdirp from "mkdirp";
+
+import { ExistingState, EnvironmentKey } from "@featurevisor/types";
+
+import { Adapter, EntityType } from "./adapter";
+import { ProjectConfig, CustomParser } from "../config";
+
+export function getExistingStateFilePath(
+  projectConfig: ProjectConfig,
+  environment: EnvironmentKey,
+): string {
+  return path.join(projectConfig.stateDirectoryPath, `existing-state-${environment}.json`);
+}
+
+export class FilesystemAdapter extends Adapter {
+  private parser: CustomParser;
+
+  constructor(private config: ProjectConfig) {
+    super();
+
+    this.parser = config.parser as CustomParser;
+  }
+
+  getEntityDirectoryPath(entityType: EntityType): string {
+    if (entityType === "feature") {
+      return this.config.featuresDirectoryPath;
+    } else if (entityType === "group") {
+      return this.config.groupsDirectoryPath;
+    } else if (entityType === "segment") {
+      return this.config.segmentsDirectoryPath;
+    } else if (entityType === "test") {
+      return this.config.testsDirectoryPath;
+    }
+
+    return this.config.attributesDirectoryPath;
+  }
+
+  getEntityPath(entityType: EntityType, entityKey: string): string {
+    const basePath = this.getEntityDirectoryPath(entityType);
+
+    return path.join(basePath, `${entityKey}.${this.parser.extension}`);
+  }
+
+  async listEntities(entityType: EntityType): Promise<string[]> {
+    const directoryPath = this.getEntityDirectoryPath(entityType);
+
+    if (!fs.existsSync(directoryPath)) {
+      return [];
+    }
+
+    return fs
+      .readdirSync(directoryPath)
+      .filter((fileName) => fileName.endsWith(`.${this.parser.extension}`))
+      .map((fileName) => fileName.replace(`.${this.parser.extension}`, ""));
+  }
+
+  async entityExists(entityType: EntityType, entityKey: string): Promise<boolean> {
+    const entityPath = this.getEntityPath(entityType, entityKey);
+
+    return fs.existsSync(entityPath);
+  }
+
+  async readEntity(entityType: EntityType, entityKey: string): Promise<string> {
+    const filePath = this.getEntityPath(entityType, entityKey);
+
+    return fs.readFileSync(filePath, "utf8");
+  }
+
+  async parseEntity<T>(entityType: EntityType, entityKey: string): Promise<T> {
+    const entityContent = await this.readEntity(entityType, entityKey);
+
+    return this.parser.parse<T>(entityContent);
+  }
+
+  /**
+   * State
+   */
+  async readState(environment: EnvironmentKey): Promise<ExistingState> {
+    const filePath = getExistingStateFilePath(this.config, environment);
+
+    if (!fs.existsSync(filePath)) {
+      return {
+        features: {},
+      };
+    }
+
+    return require(filePath);
+  }
+
+  async writeState(environment: EnvironmentKey, existingState: ExistingState) {
+    const filePath = getExistingStateFilePath(this.config, environment);
+
+    if (!fs.existsSync(this.config.stateDirectoryPath)) {
+      mkdirp.sync(this.config.stateDirectoryPath);
+    }
+    fs.writeFileSync(
+      filePath,
+      this.config.prettyState
+        ? JSON.stringify(existingState, null, 2)
+        : JSON.stringify(existingState),
+    );
+
+    fs.writeFileSync(filePath, JSON.stringify(existingState, null, 2));
+  }
+}

package/src/datasource/index.ts

@@ -1,2 +1,3 @@
 export * from "./datasource";
-export * from "./parsers";
+export * from "./adapter";
+export * from "./filesystemAdapter";

package/src/linter/checkCircularDependency.ts

@@ -25,7 +25,7 @@ export async function checkForCircularDependencyInRequired(
       throw new Error(`circular dependency found: ${chain.join(" -> ")}`);
     }
 
-    const requiredFeatureExists = await datasource.entityExists("feature", requiredKey);
+    const requiredFeatureExists = await datasource.featureExists(featureKey);
 
     if (!requiredFeatureExists) {
       throw new Error(`required feature "${requiredKey}" not found`);

package/src/{restore.ts → restore/index.ts}

@@ -1,7 +1,7 @@
 import * as path from "path";
 import { execSync } from "child_process";
 
-import { Dependencies } from "./dependencies";
+import { Dependencies } from "../dependencies";
 
 export async function restoreProject(deps: Dependencies) {
   const { rootDirectoryPath, projectConfig } = deps;

package/src/tester/testProject.ts

@@ -29,7 +29,7 @@ export async function testProject(deps: Dependencies): Promise<boolean> {
   }
 
   for (const testFile of testFiles) {
-    const testFilePath = datasource.getEntityPath("test", testFile);
+    const testFilePath = datasource.getTestSpecName(testFile);
 
     console.log("");
     console.log(CLI_FORMAT_BOLD, `Testing: ${testFilePath.replace(rootDirectoryPath, "")}`);

package/src/tester/testSegment.ts

@@ -12,7 +12,7 @@ export async function testSegment(datasource: Datasource, test: TestSegment): Pr
 
   console.log(CLI_FORMAT_BOLD, `  Segment "${segmentKey}":`);
 
-  const segmentExists = await datasource.entityExists("segment", segmentKey);
+  const segmentExists = await datasource.segmentExists(segmentKey);
 
   if (!segmentExists) {
     console.error(CLI_FORMAT_RED, `  Segment does not exist: ${segmentKey}`);

package/lib/config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":";;;AAAA,2BAA6B;AAMhB,QAAA,uBAAuB,GAAG,UAAU,CAAC;AACrC,QAAA,uBAAuB,GAAG,UAAU,CAAC;AACrC,QAAA,yBAAyB,GAAG,YAAY,CAAC;AACzC,QAAA,qBAAqB,GAAG,QAAQ,CAAC;AACjC,QAAA,oBAAoB,GAAG,OAAO,CAAC;AAC/B,QAAA,oBAAoB,GAAG,eAAe,CAAC;AACvC,QAAA,qBAAqB,GAAG,MAAM,CAAC;AAC/B,QAAA,0BAA0B,GAAG,KAAK,CAAC;AAEnC,QAAA,kBAAkB,GAAG,wBAAwB,CAAC;AAC9C,QAAA,oBAAoB,GAAG,WAAW,CAAC;AAEnC,QAAA,oBAAoB,GAAG,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;AACjD,QAAA,YAAY,GAAG,CAAC,KAAK,CAAC,CAAC;AACvB,QAAA,2BAA2B,GAAG,QAAQ,CAAC;AAEvC,QAAA,oBAAoB,GAAG,KAAK,CAAC;AAC7B,QAAA,uBAAuB,GAAG,KAAK,CAAC;AAEhC,QAAA,cAAc,GAAW,KAAK,CAAC;AAE/B,QAAA,cAAc,GAAG,GAAG,CAAC;AAmBlC,6FAA6F;AAC7F,SAAgB,gBAAgB,CAAC,iBAAyB;IACxD,IAAM,UAAU,GAAkB;QAChC,qBAAqB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,+BAAuB,CAAC;QAC5E,qBAAqB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,+BAAuB,CAAC;QAC5E,uBAAuB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,iCAAyB,CAAC;QAChF,mBAAmB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,6BAAqB,CAAC;QACxE,kBAAkB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,4BAAoB,CAAC;QAEtE,kBAAkB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,4BAAoB,CAAC;QACtE,mBAAmB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,6BAAqB,CAAC;QAExE,YAAY,EAAE,4BAAoB;QAClC,IAAI,EAAE,oBAAY;QAClB,eAAe,EAAE,QAAQ;QAEzB,MAAM,EAAE,sBAAc;QAEtB,WAAW,EAAE,4BAAoB;QACjC,cAAc,EAAE,+BAAuB;QAEvC,uBAAuB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,kCAA0B,CAAC;KAClF,CAAC;IAEF,IAAM,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,0BAAkB,CAAC,CAAC;IAC1E,IAAM,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAE/C,IAAM,WAAW,GAAG,EAAE,CAAC;IAEvB,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,UAAC,GAAG;QAClC,WAAW,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,GAAG,CAAC,CAAC;QAExD,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,4BAAoB,CAAC,KAAK,CAAC,CAAC,EAAE;YACjF,WAAW,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,4BAAoB,EAAE,iBAAiB,CAAC,CAAC;SACtF;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,WAA4B,CAAC;AACtC,CAAC;AArCD,4CAqCC"}

package/lib/datasource/parsers.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsers = void 0;
-var YAML = require("js-yaml");
-/**
- * If we want to add more built-in parsers,
- * add them to this object with new file extension as the key,
- * and a function that takes file content as string and returns parsed object as the value.
- */
-exports.parsers = {
-    // extension => function
-    yml: function (content) {
-        return YAML.load(content);
-    },
-    json: function (content) {
-        return JSON.parse(content);
-    },
-};
-//# sourceMappingURL=parsers.js.map

package/lib/datasource/parsers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parsers.js","sourceRoot":"","sources":["../../src/datasource/parsers.ts"],"names":[],"mappings":";;;AAAA,8BAAgC;AAEhC;;;;GAIG;AACU,QAAA,OAAO,GAAG;IACrB,wBAAwB;IACxB,GAAG,YAAC,OAAe;QACjB,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC5B,CAAC;IAED,IAAI,YAAC,OAAe;QAClB,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;CACF,CAAC"}

package/lib/init.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"init.js","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":";;;AAAA,+BAA0B;AAC1B,yBAA2B;AAEd,QAAA,eAAe,GAAG,aAAa,CAAC;AAEhC,QAAA,iBAAiB,GAAG,SAAS,CAAC;AAC9B,QAAA,kBAAkB,GAAG,cAAc,CAAC;AACpC,QAAA,oBAAoB,GAAG,MAAM,CAAC;AAE9B,QAAA,gBAAgB,GAAG,sCAA+B,yBAAiB,cAAI,0BAAkB,qBAAW,4BAAoB,CAAE,CAAC;AAExI,SAAS,cAAc,CAAC,WAAmB;IACzC,OAAO,UAAG,0BAAkB,cAAI,4BAAoB,uBAAa,WAAW,MAAG,CAAC;AAClF,CAAC;AAED,SAAgB,WAAW,CACzB,aAAqB,EACrB,WAAqC;IAArC,4BAAA,EAAA,cAAsB,uBAAe;IAErC,OAAO,IAAI,OAAO,CAAC,UAAU,OAAO;QAClC,eAAK,CAAC,GAAG,CAAC,wBAAgB,EAAE,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,UAAC,QAAQ;YACpE,QAAQ,CAAC,IAAI;iBACV,IAAI,CACH,GAAG,CAAC,CAAC,CAAC;gBACJ,CAAC,EAAE,aAAa;gBAChB,MAAM,EAAE,UAAC,IAAI,IAAK,OAAA,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,EAA/C,CAA+C;gBACjE,KAAK,EAAE,CAAC;aACT,CAAC,CACH;iBACA,EAAE,CAAC,OAAO,EAAE,UAAC,CAAC;gBACb,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBAEjB,OAAO,CAAC,KAAK,CAAC,CAAC;YACjB,CAAC,CAAC;iBACD,EAAE,CAAC,QAAQ,EAAE;gBACZ,OAAO,CAAC,GAAG,CAAC,gCAAyB,aAAa,CAAE,CAAC,CAAC;gBACtD,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBAChB,OAAO,CAAC,GAAG,CAAC,oDAAkD,CAAC,CAAC;gBAEhE,OAAO,CAAC,IAAI,CAAC,CAAC;YAChB,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AA5BD,kCA4BC"}

package/lib/restore.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"restore.js","sourceRoot":"","sources":["../src/restore.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2BAA6B;AAC7B,+CAAyC;AAIzC,SAAsB,cAAc,CAAC,IAAkB;;;;YAC7C,iBAAiB,GAAoB,IAAI,kBAAxB,EAAE,aAAa,GAAK,IAAI,cAAT,CAAU;YAE5C,oBAAoB,GAAG,IAAI,CAAC,QAAQ,CAAC,iBAAiB,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAC;YAC1F,GAAG,GAAG,0BAAmB,oBAAoB,SAAG,IAAI,CAAC,GAAG,CAAE,CAAC;YAEjE,IAAI;gBACF,IAAA,wBAAQ,EAAC,GAAG,EAAE;oBACZ,GAAG,EAAE,iBAAiB;iBACvB,CAAC,CAAC;gBAEH,OAAO,CAAC,GAAG,CAAC,oCAAoC,CAAC,CAAC;aACnD;YAAC,OAAO,CAAC,EAAE;gBACV,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC;gBAEjC,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;aACnD;;;;CACF;AAjBD,wCAiBC"}

package/src/datasource/parsers.ts

@@ -1,26 +0,0 @@
-import * as YAML from "js-yaml";
-
-/**
- * If we want to add more built-in parsers,
- * add them to this object with new file extension as the key,
- * and a function that takes file content as string and returns parsed object as the value.
- */
-export const parsers = {
-  // extension => function
-  yml(content: string) {
-    return YAML.load(content);
-  },
-
-  json(content: string) {
-    return JSON.parse(content);
-  },
-};
-
-export type BuiltInParser = keyof typeof parsers; // keys of parsers object
-
-export interface CustomParser {
-  extension: string;
-  parse: (content: string) => any;
-}
-
-export type Parser = BuiltInParser | CustomParser;