chore(utils): allow immutable in utils format (#1060)

src/utils/formatLines.ts

@@ -1,5 +1,5 @@
 export function formatLines(
-  lines: string[],
+  lines: ReadonlyArray<string>,
   replace = '  ',
   separator = ','
 ): string {

src/utils/formatParams.ts

@@ -2,8 +2,10 @@ import { applyType, escapeValue } from '.';
 import type { FunctionParam } from '../operations/functionsTypes';
 import type { MigrationOptions } from '../types';
 
-function formatParam(mOptions: MigrationOptions) {
-  return (param: FunctionParam) => {
+function formatParam(
+  mOptions: MigrationOptions
+): (param: FunctionParam) => string {
+  return (param) => {
     const {
       mode,
       name,
@@ -34,7 +36,7 @@ function formatParam(mOptions: MigrationOptions) {
 }
 
 export function formatParams(
-  params: FunctionParam[],
+  params: ReadonlyArray<FunctionParam>,
   mOptions: MigrationOptions
 ): string {
   return `(${params.map(formatParam(mOptions)).join(', ')})`;

test/utils/formatLines.spec.ts

@@ -42,6 +42,21 @@ describe('utils', () => {
   ADD CONSTRAINT "zipchk" EXCLUDE zipcode WITH = DEFERRABLE INITIALLY IMMEDIATE`);
     });
 
+    it('should be immutable', () => {
+      const lines: ReadonlyArray<string> = Object.freeze([
+        'CONSTRAINT "zipchk" CHECK (char_length(zipcode) = 5) DEFERRABLE INITIALLY IMMEDIATE',
+        'CONSTRAINT "zipchk" CHECK (zipcode <> 0) DEFERRABLE INITIALLY IMMEDIATE',
+        'CONSTRAINT "zipchk" EXCLUDE zipcode WITH = DEFERRABLE INITIALLY IMMEDIATE',
+      ]);
+      const actual = formatLines(lines, '  ADD ');
+
+      expect(actual).toBeTypeOf('string');
+      expect(actual)
+        .toBe(`  ADD CONSTRAINT "zipchk" CHECK (char_length(zipcode) = 5) DEFERRABLE INITIALLY IMMEDIATE,
+  ADD CONSTRAINT "zipchk" CHECK (zipcode <> 0) DEFERRABLE INITIALLY IMMEDIATE,
+  ADD CONSTRAINT "zipchk" EXCLUDE zipcode WITH = DEFERRABLE INITIALLY IMMEDIATE`);
+    });
+
     it('should replace newlines with a whitespace', () => {
       const actual = formatLines(['a\r\nb', 'c\rd', 'e\nf']);
 

test/utils/formatParam.spec.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from 'vitest';
+import type { FunctionParam } from '../../src';
+import { PgType } from '../../src';
+import type { MigrationOptions } from '../../src/types';
+import { formatParams } from '../../src/utils';
+import { options1 } from '../presetMigrationOptions';
+
+describe('utils', () => {
+  describe('formatParams', () => {
+    // TODO @Shinigami92 2024-04-04: Should this throw an error if empty array was passed?
+    it('should return empty braces', () => {
+      const actual = formatParams([], options1);
+
+      expect(actual).toBeTypeOf('string');
+      expect(actual).toBe('()');
+    });
+
+    it('should apply default shorthand', () => {
+      const actual = formatParams(
+        [
+          { type: 'int' },
+          { type: 'string' },
+          { type: 'float' },
+          { type: 'double' },
+          { type: 'datetime' },
+          { type: 'bool' },
+        ],
+        options1
+      );
+
+      expect(actual).toBeTypeOf('string');
+      expect(actual).toBe(
+        '(integer, text, real, double precision, timestamp, boolean)'
+      );
+    });
+
+    it('should consume PgType value', () => {
+      const actual = formatParams([{ type: PgType.BYTEA }], options1);
+
+      expect(actual).toBeTypeOf('string');
+      expect(actual).toBe('(bytea)');
+    });
+
+    it('should consume simple string type params', () => {
+      const actual = formatParams(['int', 'bigint'], options1);
+
+      expect(actual).toBeTypeOf('string');
+      expect(actual).toBe('(integer, bigint)');
+    });
+
+    it('should consume complex object params', () => {
+      const actual = formatParams(
+        [
+          {
+            mode: 'OUT',
+            name: 'test',
+            type: PgType.BIGINT,
+            default: true,
+          },
+          {
+            mode: 'INOUT',
+            name: 'test2',
+            type: PgType.BOX,
+            default: false,
+          },
+        ],
+        options1
+      );
+
+      expect(actual).toBeTypeOf('string');
+      expect(actual).toBe(
+        '(OUT "test" bigint DEFAULT true, INOUT "test2" box)'
+      );
+    });
+
+    it('should be immutable', () => {
+      const params: ReadonlyArray<FunctionParam> = Object.freeze([
+        'int',
+        PgType.BIGINT,
+        {
+          mode: 'OUT',
+          name: 'test',
+          type: 'bigint',
+          default: true,
+        },
+        {
+          mode: 'VARIADIC',
+          name: 'test2',
+          type: PgType.BOX,
+          default: false,
+        },
+      ]);
+      const mOptions: Readonly<MigrationOptions> = Object.freeze(options1);
+      const actual = formatParams(params, mOptions);
+
+      expect(actual).toBeTypeOf('string');
+      expect(actual).toBe(
+        '(integer, bigint, OUT "test" bigint DEFAULT true, VARIADIC "test2" box)'
+      );
+    });
+  });
+});