@ttoss/cloudformation 0.2.0

package/dist/esm/index.js

@@ -0,0 +1,221 @@
+/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/findAndReadCloudFormationTemplate.ts
+import * as fs3 from "fs";
+import * as path2 from "path";
+
+// src/readCloudFormationYamlTemplate.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/cloudFormationTemplate.ts
+import yaml from "js-yaml";
+var cloudFormationTypes = [
+  {
+    tag: "!Equals",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::Equals": data };
+      }
+    }
+  },
+  {
+    tag: "!FindInMap",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::FindInMap": data };
+      }
+    }
+  },
+  {
+    tag: "!GetAtt",
+    options: {
+      kind: "scalar",
+      construct: (data) => {
+        return { "Fn::GetAtt": data.split(".") };
+      }
+    }
+  },
+  {
+    tag: "!GetAtt",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::GetAtt": data };
+      }
+    }
+  },
+  {
+    tag: "!If",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::If": data };
+      }
+    }
+  },
+  {
+    tag: "!ImportValue",
+    options: {
+      kind: "scalar",
+      construct: (data) => {
+        return { "Fn::ImportValue": data };
+      }
+    }
+  },
+  {
+    tag: "!Join",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::Join": data };
+      }
+    }
+  },
+  {
+    tag: "!Not",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::Not": data };
+      }
+    }
+  },
+  {
+    tag: "!Ref",
+    options: {
+      kind: "scalar",
+      construct: (data) => {
+        return { Ref: data };
+      }
+    }
+  },
+  {
+    tag: "!Sub",
+    options: {
+      kind: "scalar",
+      construct: (data) => {
+        return { "Fn::Sub": data };
+      }
+    }
+  },
+  {
+    tag: "!Sub",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::Sub": data };
+      }
+    }
+  }
+];
+var getYamlTypes = (tagAndTypeArr) => {
+  return tagAndTypeArr.map(({ tag, options }) => {
+    return new yaml.Type(tag, options);
+  });
+};
+var getSchema = (tagAndTypeArr = []) => {
+  return yaml.DEFAULT_SCHEMA.extend(
+    getYamlTypes([...tagAndTypeArr, ...cloudFormationTypes])
+  );
+};
+var loadCloudFormationTemplate = (template, tagAndTypeArr = []) => {
+  return yaml.load(template, { schema: getSchema(tagAndTypeArr) });
+};
+
+// src/readCloudFormationYamlTemplate.ts
+var getTypes = () => {
+  return [
+    {
+      tag: `!SubString`,
+      options: {
+        kind: "scalar",
+        construct: (filePath) => {
+          return fs.readFileSync(path.resolve(process.cwd(), filePath)).toString();
+        }
+      }
+    }
+  ];
+};
+var readCloudFormationYamlTemplate = ({
+  templatePath
+}) => {
+  const template = fs.readFileSync(templatePath).toString();
+  const parsed = loadCloudFormationTemplate(template, getTypes());
+  if (!parsed || typeof parsed === "string") {
+    throw new Error("Cannot parse CloudFormation template.");
+  }
+  return parsed;
+};
+
+// src/readObjectFile.ts
+import fs2 from "fs";
+import yaml2 from "js-yaml";
+var readYaml = ({ path: path3 }) => {
+  const template = fs2.readFileSync(path3, "utf8") || JSON.stringify({});
+  return yaml2.load(template);
+};
+var readObjectFile = ({ path: path3 }) => {
+  if (!fs2.existsSync(path3)) {
+    return {};
+  }
+  const extension = path3.split(".").pop();
+  if (extension === "ts") {
+    __require("ts-node").register({
+      compilerOptions: { module: "commonjs" },
+      transpileOnly: true
+    });
+    const tsObj = __require(path3);
+    const obj = tsObj.default || tsObj;
+    return typeof obj === "function" ? obj() : obj;
+  }
+  if (extension === "js") {
+    const obj = __require(path3);
+    return typeof obj === "function" ? obj() : obj;
+  }
+  if (extension === "json") {
+    return __require(path3);
+  }
+  if (extension === "yml" || extension === "yaml") {
+    return readYaml({ path: path3 });
+  }
+  return {};
+};
+
+// src/findAndReadCloudFormationTemplate.ts
+var defaultTemplatePaths = ["ts", "js", "yaml", "yml", "json"].map(
+  (extension) => {
+    return `./src/cloudformation.${extension}`;
+  }
+);
+var findAndReadCloudFormationTemplate = ({
+  templatePath: defaultTemplatePath
+}) => {
+  const templatePath = defaultTemplatePath || defaultTemplatePaths.reduce((acc, cur) => {
+    if (acc) {
+      return acc;
+    }
+    return fs3.existsSync(path2.resolve(process.cwd(), cur)) ? cur : acc;
+  }, "");
+  if (!templatePath) {
+    throw new Error("Cannot find a CloudFormation template.");
+  }
+  const extension = templatePath?.split(".").pop();
+  const fullPath = path2.resolve(process.cwd(), templatePath);
+  if (["yaml", "yml"].includes(extension)) {
+    return readCloudFormationYamlTemplate({ templatePath });
+  }
+  return readObjectFile({ path: fullPath });
+};
+export {
+  findAndReadCloudFormationTemplate
+};

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+interface Parameter {
+    AllowedValues?: string[];
+    Default?: string | number;
+    Description?: string;
+    Type: string;
+    NoEcho?: boolean;
+}
+interface Resource {
+    Type: string;
+    DeletionPolicy?: 'Delete' | 'Retain';
+    Description?: string;
+    DependsOn?: string[] | string;
+    Condition?: string;
+    Properties: any;
+}
+type Output = {
+    Description?: string;
+    Value: string | any;
+    Export?: {
+        Name: string | any;
+    };
+};
+interface CloudFormationTemplate {
+    AWSTemplateFormatVersion: '2010-09-09';
+    Transform?: 'AWS::Serverless-2016-10-31';
+    Mappings?: any;
+    Conditions?: any;
+    Parameters?: {
+        [key: string]: Parameter;
+    };
+    Resources: {
+        [key: string]: Resource;
+    };
+    Outputs?: {
+        [key: string]: Output;
+    };
+}
+
+declare const findAndReadCloudFormationTemplate: ({ templatePath: defaultTemplatePath, }: {
+    templatePath?: string;
+}) => CloudFormationTemplate;
+
+export { findAndReadCloudFormationTemplate };

package/dist/index.js

@@ -0,0 +1,246 @@
+/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  findAndReadCloudFormationTemplate: () => findAndReadCloudFormationTemplate
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/findAndReadCloudFormationTemplate.ts
+var fs3 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+
+// src/readCloudFormationYamlTemplate.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+
+// src/cloudFormationTemplate.ts
+var import_js_yaml = __toESM(require("js-yaml"));
+var cloudFormationTypes = [
+  {
+    tag: "!Equals",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::Equals": data };
+      }
+    }
+  },
+  {
+    tag: "!FindInMap",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::FindInMap": data };
+      }
+    }
+  },
+  {
+    tag: "!GetAtt",
+    options: {
+      kind: "scalar",
+      construct: (data) => {
+        return { "Fn::GetAtt": data.split(".") };
+      }
+    }
+  },
+  {
+    tag: "!GetAtt",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::GetAtt": data };
+      }
+    }
+  },
+  {
+    tag: "!If",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::If": data };
+      }
+    }
+  },
+  {
+    tag: "!ImportValue",
+    options: {
+      kind: "scalar",
+      construct: (data) => {
+        return { "Fn::ImportValue": data };
+      }
+    }
+  },
+  {
+    tag: "!Join",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::Join": data };
+      }
+    }
+  },
+  {
+    tag: "!Not",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::Not": data };
+      }
+    }
+  },
+  {
+    tag: "!Ref",
+    options: {
+      kind: "scalar",
+      construct: (data) => {
+        return { Ref: data };
+      }
+    }
+  },
+  {
+    tag: "!Sub",
+    options: {
+      kind: "scalar",
+      construct: (data) => {
+        return { "Fn::Sub": data };
+      }
+    }
+  },
+  {
+    tag: "!Sub",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::Sub": data };
+      }
+    }
+  }
+];
+var getYamlTypes = (tagAndTypeArr) => {
+  return tagAndTypeArr.map(({ tag, options }) => {
+    return new import_js_yaml.default.Type(tag, options);
+  });
+};
+var getSchema = (tagAndTypeArr = []) => {
+  return import_js_yaml.default.DEFAULT_SCHEMA.extend(
+    getYamlTypes([...tagAndTypeArr, ...cloudFormationTypes])
+  );
+};
+var loadCloudFormationTemplate = (template, tagAndTypeArr = []) => {
+  return import_js_yaml.default.load(template, { schema: getSchema(tagAndTypeArr) });
+};
+
+// src/readCloudFormationYamlTemplate.ts
+var getTypes = () => {
+  return [
+    {
+      tag: `!SubString`,
+      options: {
+        kind: "scalar",
+        construct: (filePath) => {
+          return fs.readFileSync(path.resolve(process.cwd(), filePath)).toString();
+        }
+      }
+    }
+  ];
+};
+var readCloudFormationYamlTemplate = ({
+  templatePath
+}) => {
+  const template = fs.readFileSync(templatePath).toString();
+  const parsed = loadCloudFormationTemplate(template, getTypes());
+  if (!parsed || typeof parsed === "string") {
+    throw new Error("Cannot parse CloudFormation template.");
+  }
+  return parsed;
+};
+
+// src/readObjectFile.ts
+var import_fs = __toESM(require("fs"));
+var import_js_yaml2 = __toESM(require("js-yaml"));
+var readYaml = ({ path: path3 }) => {
+  const template = import_fs.default.readFileSync(path3, "utf8") || JSON.stringify({});
+  return import_js_yaml2.default.load(template);
+};
+var readObjectFile = ({ path: path3 }) => {
+  if (!import_fs.default.existsSync(path3)) {
+    return {};
+  }
+  const extension = path3.split(".").pop();
+  if (extension === "ts") {
+    require("ts-node").register({
+      compilerOptions: { module: "commonjs" },
+      transpileOnly: true
+    });
+    const tsObj = require(path3);
+    const obj = tsObj.default || tsObj;
+    return typeof obj === "function" ? obj() : obj;
+  }
+  if (extension === "js") {
+    const obj = require(path3);
+    return typeof obj === "function" ? obj() : obj;
+  }
+  if (extension === "json") {
+    return require(path3);
+  }
+  if (extension === "yml" || extension === "yaml") {
+    return readYaml({ path: path3 });
+  }
+  return {};
+};
+
+// src/findAndReadCloudFormationTemplate.ts
+var defaultTemplatePaths = ["ts", "js", "yaml", "yml", "json"].map(
+  (extension) => {
+    return `./src/cloudformation.${extension}`;
+  }
+);
+var findAndReadCloudFormationTemplate = ({
+  templatePath: defaultTemplatePath
+}) => {
+  const templatePath = defaultTemplatePath || defaultTemplatePaths.reduce((acc, cur) => {
+    if (acc) {
+      return acc;
+    }
+    return fs3.existsSync(path2.resolve(process.cwd(), cur)) ? cur : acc;
+  }, "");
+  if (!templatePath) {
+    throw new Error("Cannot find a CloudFormation template.");
+  }
+  const extension = templatePath?.split(".").pop();
+  const fullPath = path2.resolve(process.cwd(), templatePath);
+  if (["yaml", "yml"].includes(extension)) {
+    return readCloudFormationYamlTemplate({ templatePath });
+  }
+  return readObjectFile({ path: fullPath });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findAndReadCloudFormationTemplate
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@ttoss/cloudformation",
+  "version": "0.2.0",
+  "description": "CloudFormation utils.",
+  "license": "UNLICENSED",
+  "author": "ttoss",
+  "contributors": [
+    "Pedro Arantes <pedro@arantespp.com> (https://arantespp.com)"
+  ],
+  "main": "dist/index.js",
+  "module": "dist/esm/index.js",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "echo test"
+  },
+  "typings": "dist/index.d.ts",
+  "dependencies": {
+    "js-yaml": "^4.1.0",
+    "ts-node": "^10.9.1"
+  },
+  "devDependencies": {
+    "@ttoss/config": "^1.25.0"
+  },
+  "keywords": [],
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "9ad8b28e9ca906af04b2e0c3743bf453b8701429"
+}

package/src/cloudFormationTemplate.ts

@@ -0,0 +1,185 @@
+import yaml from 'js-yaml';
+
+interface Parameter {
+  AllowedValues?: string[];
+  Default?: string | number;
+  Description?: string;
+  Type: string;
+  NoEcho?: boolean;
+}
+
+export interface Resource {
+  Type: string;
+  DeletionPolicy?: 'Delete' | 'Retain';
+  Description?: string;
+  DependsOn?: string[] | string;
+  Condition?: string;
+  Properties: any;
+}
+
+export type Output = {
+  Description?: string;
+  Value: string | any;
+  Export?: {
+    Name: string | any;
+  };
+};
+
+export interface CloudFormationTemplate {
+  AWSTemplateFormatVersion: '2010-09-09';
+  Transform?: 'AWS::Serverless-2016-10-31';
+  Mappings?: any;
+  Conditions?: any;
+  Parameters?: { [key: string]: Parameter };
+  Resources: { [key: string]: Resource };
+  Outputs?: { [key: string]: Output };
+}
+
+export interface TagAndType {
+  tag: string;
+  options: yaml.TypeConstructorOptions;
+}
+
+const cloudFormationTypes: TagAndType[] = [
+  {
+    tag: '!Equals',
+    options: {
+      kind: 'sequence',
+      construct: (data: any) => {
+        return { 'Fn::Equals': data };
+      },
+    },
+  },
+  {
+    tag: '!FindInMap',
+    options: {
+      kind: 'sequence',
+      construct: (data: any) => {
+        return { 'Fn::FindInMap': data };
+      },
+    },
+  },
+  {
+    tag: '!GetAtt',
+    options: {
+      kind: 'scalar',
+      construct: (data: any) => {
+        return { 'Fn::GetAtt': data.split('.') };
+      },
+    },
+  },
+  {
+    tag: '!GetAtt',
+    options: {
+      kind: 'sequence',
+      construct: (data: any) => {
+        return { 'Fn::GetAtt': data };
+      },
+    },
+  },
+  {
+    tag: '!If',
+    options: {
+      kind: 'sequence',
+      construct: (data: any) => {
+        return { 'Fn::If': data };
+      },
+    },
+  },
+  {
+    tag: '!ImportValue',
+    options: {
+      kind: 'scalar',
+      construct: (data: any) => {
+        return { 'Fn::ImportValue': data };
+      },
+    },
+  },
+  {
+    tag: '!Join',
+    options: {
+      kind: 'sequence',
+      construct: (data: any) => {
+        return { 'Fn::Join': data };
+      },
+    },
+  },
+  {
+    tag: '!Not',
+    options: {
+      kind: 'sequence',
+      construct: (data: any) => {
+        return { 'Fn::Not': data };
+      },
+    },
+  },
+  {
+    tag: '!Ref',
+    options: {
+      kind: 'scalar',
+      construct: (data: any) => {
+        return { Ref: data };
+      },
+    },
+  },
+  {
+    tag: '!Sub',
+    options: {
+      kind: 'scalar',
+      construct: (data: any) => {
+        return { 'Fn::Sub': data };
+      },
+    },
+  },
+  {
+    tag: '!Sub',
+    options: {
+      kind: 'sequence',
+      construct: (data: any) => {
+        return { 'Fn::Sub': data };
+      },
+    },
+  },
+];
+
+const getYamlTypes = (tagAndTypeArr: TagAndType[]) => {
+  return tagAndTypeArr.map(({ tag, options }) => {
+    return new yaml.Type(tag, options);
+  });
+};
+
+/**
+ * Transform CloudFormation directives in objects. For example, transform
+ * !Ref Something in { Ref: Something }.
+ */
+export const getSchema = (tagAndTypeArr: TagAndType[] = []) => {
+  return yaml.DEFAULT_SCHEMA.extend(
+    getYamlTypes([...tagAndTypeArr, ...cloudFormationTypes])
+  );
+};
+
+/**
+ * Transform a JSON in a YAML string.
+ *
+ * @param cloudFormationTemplate JSON CloudFormation template
+ * @returns YAML as string
+ */
+export const dumpToYamlCloudFormationTemplate = (
+  cloudFormationTemplate: CloudFormationTemplate
+) => {
+  return yaml.dump(cloudFormationTemplate, { schema: getSchema() });
+};
+
+/**
+ * Transform YAML string in JSON object.
+ *
+ * @param template template in String format.
+ * @param tagAndTypeArr YAML types.
+ * @returns JSON template.
+ */
+export const loadCloudFormationTemplate = (
+  template: string,
+  tagAndTypeArr: TagAndType[] = []
+) => {
+  return yaml.load(template, { schema: getSchema(tagAndTypeArr) });
+};

package/src/findAndReadCloudFormationTemplate.ts

@@ -0,0 +1,52 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { CloudFormationTemplate } from './cloudFormationTemplate';
+import { readCloudFormationYamlTemplate } from './readCloudFormationYamlTemplate';
+import { readObjectFile } from './readObjectFile';
+
+export const defaultTemplatePaths = ['ts', 'js', 'yaml', 'yml', 'json'].map(
+  (extension) => {
+    return `./src/cloudformation.${extension}`;
+  }
+);
+
+export const findAndReadCloudFormationTemplate = ({
+  templatePath: defaultTemplatePath,
+}: {
+  templatePath?: string;
+}): CloudFormationTemplate => {
+  const templatePath =
+    defaultTemplatePath ||
+    defaultTemplatePaths
+      /**
+       * Iterate over extensions. If the template of the current extension is
+       * found, we save it on the accumulator and return it every time until
+       * the loop ends.
+       */
+      .reduce((acc, cur) => {
+        if (acc) {
+          return acc;
+        }
+
+        return fs.existsSync(path.resolve(process.cwd(), cur)) ? cur : acc;
+      }, '');
+
+  if (!templatePath) {
+    throw new Error('Cannot find a CloudFormation template.');
+  }
+
+  const extension = templatePath?.split('.').pop() as string;
+
+  const fullPath = path.resolve(process.cwd(), templatePath);
+
+  /**
+   * We need to read Yaml first because CloudFormation specific tags aren't
+   * recognized when parsing a simple Yaml file. I.e., a possible error:
+   * "Error message: "unknown tag !<!Ref> at line 21, column 34:\n"
+   */
+  if (['yaml', 'yml'].includes(extension)) {
+    return readCloudFormationYamlTemplate({ templatePath });
+  }
+
+  return readObjectFile({ path: fullPath });
+};

package/src/index.ts

@@ -0,0 +1 @@
+export { findAndReadCloudFormationTemplate } from './findAndReadCloudFormationTemplate';

package/src/readCloudFormationYamlTemplate.ts

@@ -0,0 +1,43 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  CloudFormationTemplate,
+  TagAndType,
+  loadCloudFormationTemplate,
+} from './cloudFormationTemplate';
+
+const getTypes = (): TagAndType[] => {
+  return [
+    {
+      tag: `!SubString`,
+      options: {
+        kind: 'scalar',
+        construct: (filePath: string) => {
+          return fs
+            .readFileSync(path.resolve(process.cwd(), filePath))
+            .toString();
+        },
+      },
+    },
+  ];
+};
+
+/**
+ * CloudFormation
+ * @param param0
+ */
+export const readCloudFormationYamlTemplate = ({
+  templatePath,
+}: {
+  templatePath: string;
+}): CloudFormationTemplate => {
+  const template = fs.readFileSync(templatePath).toString();
+
+  const parsed = loadCloudFormationTemplate(template, getTypes());
+
+  if (!parsed || typeof parsed === 'string') {
+    throw new Error('Cannot parse CloudFormation template.');
+  }
+
+  return parsed as CloudFormationTemplate;
+};

package/src/readObjectFile.ts

@@ -0,0 +1,48 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+import fs from 'fs';
+import yaml from 'js-yaml';
+
+export const readYaml = ({ path }: { path: string }) => {
+  const template = fs.readFileSync(path, 'utf8') || JSON.stringify({});
+  return yaml.load(template);
+};
+
+/**
+ * If your file is `.ts`, you must you must export the final object
+ * `export default { ... }`. If your file is `.js`, you must you must export
+ * the final object `module.exports =  { ... }`. `.json` and `.yml/yaml` must
+ * define the resources in [JSON](https://www.json.org/json-en.html) and
+ * [YAML](https://yaml.org/) format respectively.
+ */
+export const readObjectFile = ({ path }: { path: string }) => {
+  if (!fs.existsSync(path)) {
+    return {};
+  }
+
+  const extension = path.split('.').pop();
+
+  if (extension === 'ts') {
+    require('ts-node').register({
+      compilerOptions: { module: 'commonjs' },
+      transpileOnly: true,
+    });
+    const tsObj = require(path);
+    const obj = tsObj.default || tsObj;
+    return typeof obj === 'function' ? obj() : obj;
+  }
+
+  if (extension === 'js') {
+    const obj = require(path);
+    return typeof obj === 'function' ? obj() : obj;
+  }
+
+  if (extension === 'json') {
+    return require(path);
+  }
+
+  if (extension === 'yml' || extension === 'yaml') {
+    return readYaml({ path });
+  }
+
+  return {};
+};