@ttoss/cloudformation 0.10.9 → 0.10.11

package/src/cloudFormationYamlTemplate.ts

@@ -1,151 +0,0 @@
-import { CloudFormationTemplate } from './CloudFormationTemplate';
-import yaml from 'js-yaml';
-
-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

@@ -1,54 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { type CloudFormationTemplate } from './CloudFormationTemplate';
-import { readCloudFormationYamlTemplate } from './readCloudFormationYamlTemplate';
-import { readConfigFile } from '@ttoss/read-config-file';
-
-export const defaultTemplatePaths = ['ts', 'js', 'yaml', 'yml', 'json'].map(
-  (extension) => {
-    return `./src/cloudformation.${extension}`;
-  }
-);
-
-export const findAndReadCloudFormationTemplate = async ({
-  templatePath: defaultTemplatePath,
-  options = {},
-}: {
-  templatePath?: string;
-  options?: unknown;
-}): Promise<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;
-
-  /**
-   * 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 });
-  }
-
-  const configFilePath = path.resolve(process.cwd(), templatePath);
-
-  return readConfigFile({ configFilePath, options });
-};

package/src/index.ts

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

package/src/readCloudFormationYamlTemplate.ts

@@ -1,43 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { CloudFormationTemplate } from './CloudFormationTemplate';
-import {
-  TagAndType,
-  loadCloudFormationTemplate,
-} from './cloudFormationYamlTemplate';
-
-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;
-};