refactor(functions): reorganize operations functions (#1074)

src/index.ts

@@ -2,11 +2,13 @@ export { Migration } from './migration';
 export type {
   AlterDomain,
   CreateDomain,
+  CreateDomainFn,
   DomainOptions,
   DomainOptionsAlter,
   DomainOptionsCreate,
   DropDomain,
   RenameDomain,
+  RenameDomainFn,
 } from './operations/domains';
 export type {
   CreateExtension,
@@ -18,11 +20,14 @@ export type {
 } from './operations/extensions';
 export type {
   CreateFunction,
+  CreateFunctionFn,
   DropFunction,
   FunctionOptions,
   FunctionParam,
+  FunctionParamType,
   RenameFunction,
-} from './operations/functionsTypes';
+  RenameFunctionFn,
+} from './operations/functions';
 export type {
   CascadeOption,
   DropOptions,

src/operations/domains/createDomain.ts

@@ -8,7 +8,7 @@ export interface DomainOptionsCreate extends DomainOptions {
   collation?: string;
 }
 
-type CreateDomainFn = (
+export type CreateDomainFn = (
   domainName: Name,
   type: Type,
   domainOptions?: DomainOptionsCreate & DropOptions

src/operations/domains/renameDomain.ts

@@ -1,7 +1,7 @@
 import type { MigrationOptions } from '../../types';
 import type { Name } from '../generalTypes';
 
-type RenameDomainFn = (
+export type RenameDomainFn = (
   oldDomainName: Name,
   newDomainName: Name
 ) => string | string[];

src/operations/functions/createFunction.ts

@@ -0,0 +1,72 @@
+import type { MigrationOptions } from '../../types';
+import { escapeValue, formatParams } from '../../utils';
+import type { DropOptions, Name, Value } from '../generalTypes';
+import { dropFunction } from './dropFunction';
+import type { FunctionOptions, FunctionParam } from './shared';
+
+export type CreateFunctionFn = (
+  functionName: Name,
+  functionParams: FunctionParam[],
+  functionOptions: FunctionOptions & DropOptions,
+  definition: Value
+) => string | string[];
+
+export type CreateFunction = CreateFunctionFn & { reverse: CreateFunctionFn };
+
+export function createFunction(mOptions: MigrationOptions): CreateFunction {
+  const _create: CreateFunction = (
+    functionName,
+    functionParams = [],
+    functionOptions,
+    definition
+  ) => {
+    const {
+      replace,
+      returns = 'void',
+      language,
+      window,
+      behavior = 'VOLATILE',
+      onNull,
+      parallel,
+    } = functionOptions;
+
+    const options: string[] = [];
+
+    if (behavior) {
+      options.push(behavior);
+    }
+
+    if (language) {
+      options.push(`LANGUAGE ${language}`);
+    } else {
+      throw new Error(
+        `Language for function ${functionName} have to be specified`
+      );
+    }
+
+    if (window) {
+      options.push('WINDOW');
+    }
+
+    if (onNull) {
+      options.push('RETURNS NULL ON NULL INPUT');
+    }
+
+    if (parallel) {
+      options.push(`PARALLEL ${parallel}`);
+    }
+
+    const replaceStr = replace ? ' OR REPLACE' : '';
+    const paramsStr = formatParams(functionParams, mOptions);
+    const functionNameStr = mOptions.literal(functionName);
+
+    return `CREATE${replaceStr} FUNCTION ${functionNameStr}${paramsStr}
+  RETURNS ${returns}
+  AS ${escapeValue(definition)}
+  ${options.join('\n  ')};`;
+  };
+
+  _create.reverse = dropFunction(mOptions);
+
+  return _create;
+}

src/operations/functions/dropFunction.ts

@@ -0,0 +1,29 @@
+import type { MigrationOptions } from '../../types';
+import { formatParams } from '../../utils';
+import type { DropOptions, Name } from '../generalTypes';
+import type { FunctionParam } from './shared';
+
+export type DropFunction = (
+  functionName: Name,
+  functionParams: FunctionParam[],
+  dropOptions?: DropOptions
+) => string | string[];
+
+export function dropFunction(mOptions: MigrationOptions): DropFunction {
+  const _drop: DropFunction = (
+    functionName,
+    functionParams = [],
+    options = {}
+  ) => {
+    const { ifExists, cascade } = options;
+
+    const ifExistsStr = ifExists ? ' IF EXISTS' : '';
+    const cascadeStr = cascade ? ' CASCADE' : '';
+    const paramsStr = formatParams(functionParams, mOptions);
+    const functionNameStr = mOptions.literal(functionName);
+
+    return `DROP FUNCTION${ifExistsStr} ${functionNameStr}${paramsStr}${cascadeStr};`;
+  };
+
+  return _drop;
+}

src/operations/functions/index.ts

@@ -0,0 +1,4 @@
+export * from './createFunction';
+export * from './dropFunction';
+export * from './renameFunction';
+export * from './shared';

src/operations/functions/renameFunction.ts

@@ -0,0 +1,31 @@
+import type { MigrationOptions } from '../../types';
+import { formatParams } from '../../utils';
+import type { Name } from '../generalTypes';
+import type { FunctionParam } from './shared';
+
+export type RenameFunctionFn = (
+  oldFunctionName: Name,
+  functionParams: FunctionParam[],
+  newFunctionName: Name
+) => string | string[];
+
+export type RenameFunction = RenameFunctionFn & { reverse: RenameFunctionFn };
+
+export function renameFunction(mOptions: MigrationOptions): RenameFunction {
+  const _rename: RenameFunction = (
+    oldFunctionName,
+    functionParams = [],
+    newFunctionName
+  ) => {
+    const paramsStr = formatParams(functionParams, mOptions);
+    const oldFunctionNameStr = mOptions.literal(oldFunctionName);
+    const newFunctionNameStr = mOptions.literal(newFunctionName);
+
+    return `ALTER FUNCTION ${oldFunctionNameStr}${paramsStr} RENAME TO ${newFunctionNameStr};`;
+  };
+
+  _rename.reverse = (oldFunctionName, functionParams, newFunctionName) =>
+    _rename(newFunctionName, functionParams, oldFunctionName);
+
+  return _rename;
+}

src/operations/functions/shared.ts

@@ -0,0 +1,29 @@
+import type { Value } from '../generalTypes';
+
+export interface FunctionParamType {
+  mode?: 'IN' | 'OUT' | 'INOUT' | 'VARIADIC';
+
+  name?: string;
+
+  type: string;
+
+  default?: Value;
+}
+
+export type FunctionParam = string | FunctionParamType;
+
+export interface FunctionOptions {
+  returns?: string;
+
+  language: string;
+
+  replace?: boolean;
+
+  window?: boolean;
+
+  behavior?: 'IMMUTABLE' | 'STABLE' | 'VOLATILE';
+
+  onNull?: boolean;
+
+  parallel?: 'UNSAFE' | 'RESTRICTED' | 'SAFE';
+}

src/operations/operatorsTypes.ts

@@ -1,4 +1,4 @@
-import type { FunctionParam } from './functionsTypes';
+import type { FunctionParam } from './functions';
 import type { DropOptions, Name, Type } from './generalTypes';
 
 export interface CreateOperatorOptions {

src/operations/tables.ts

@@ -7,7 +7,7 @@ import {
   intersection,
   makeComment,
 } from '../utils';
-import type { FunctionParamType } from './functionsTypes';
+import type { FunctionParamType } from './functions';
 import type { Name } from './generalTypes';
 import { parseSequenceOptions } from './sequences';
 import type {