salsita · dolezel · Jun 26, 2018 · Jun 25, 2018
diff --git a/lib/operations/domains.js b/lib/operations/domains.js
@@ -1,12 +1,12 @@
 import { template, applyType, escapeValue } from "../utils";
 
-export const dropDomain = (domainName, { ifExists, cascade } = {}) => {
+export function dropDomain(domainName, { ifExists, cascade } = {}) {
   const ifExistsStr = ifExists ? " IF EXISTS" : "";
   const cascadeStr = cascade ? " CASCADE" : "";
   return template`DROP DOMAIN${ifExistsStr} "${domainName}"${cascadeStr};`;
-};
+}
 
-export const createDomain = typeShorthands => {
+export function createDomain(typeShorthands) {
   const _create = (domainName, type, options = {}) => {
     const {
       default: defaultValue,
@@ -46,9 +46,9 @@ export const createDomain = typeShorthands => {
   _create.reverse = (domainName, type, options) =>
     dropDomain(domainName, options);
   return _create;
-};
+}
 
-export const alterDomain = (domainName, options) => {
+export function alterDomain(domainName, options) {
   const {
     default: defaultValue,
     notNull,
@@ -76,10 +76,11 @@ export const alterDomain = (domainName, options) => {
   return `${actions
     .map(action => template`ALTER DOMAIN "${domainName}" ${action}`)
     .join(";\n")};`;
-};
+}
 
-export const renameDomain = (domainName, newDomainName) =>
-  template`ALTER DOMAIN  "${domainName}" RENAME TO "${newDomainName}";`;
+export function renameDomain(domainName, newDomainName) {
+  return template`ALTER DOMAIN  "${domainName}" RENAME TO "${newDomainName}";`;
+}
 
 const undoRename = (domainName, newDomainName) =>
   renameDomain(newDomainName, domainName);

diff --git a/lib/operations/extensions.js b/lib/operations/extensions.js
@@ -1,7 +1,7 @@
 import _ from "lodash";
 import { template } from "../utils";
 
-export const createExtension = (extensions, { ifNotExists, schema } = {}) => {
+export function createExtension(extensions, { ifNotExists, schema } = {}) {
   if (!_.isArray(extensions)) extensions = [extensions]; // eslint-disable-line no-param-reassign
   return _.map(
     extensions,
@@ -10,9 +10,9 @@ export const createExtension = (extensions, { ifNotExists, schema } = {}) => {
         ifNotExists ? " IF NOT EXISTS" : ""
       } "${extension}"${schema ? ` SCHEMA "${schema}"` : ""};`
   );
-};
+}
 
-export const dropExtension = (extensions, { ifExists, cascade } = {}) => {
+export function dropExtension(extensions, { ifExists, cascade } = {}) {
   if (!_.isArray(extensions)) extensions = [extensions]; // eslint-disable-line no-param-reassign
   return _.map(
     extensions,
@@ -21,7 +21,7 @@ export const dropExtension = (extensions, { ifExists, cascade } = {}) => {
         cascade ? " CASCADE" : ""
       };`
   );
-};
+}
 
 // setup reverse functions
 createExtension.reverse = dropExtension;
diff --git a/lib/operations/functions.js b/lib/operations/functions.js
@@ -1,17 +1,15 @@
 import { template, escapeValue, formatParams } from "../utils";
 
-export const dropFunction = typeShorthands => (
-  functionName,
-  functionParams = [],
-  { ifExists, cascade } = {}
-) => {
-  const ifExistsStr = ifExists ? " IF EXISTS" : "";
-  const cascadeStr = cascade ? " CASCADE" : "";
-  const paramsStr = formatParams(functionParams, typeShorthands);
-  return template`DROP FUNCTION${ifExistsStr} "${functionName}"${paramsStr}${cascadeStr};`;
-};
+export function dropFunction(typeShorthands) {
+  return (functionName, functionParams = [], { ifExists, cascade } = {}) => {
+    const ifExistsStr = ifExists ? " IF EXISTS" : "";
+    const cascadeStr = cascade ? " CASCADE" : "";
+    const paramsStr = formatParams(functionParams, typeShorthands);
+    return template`DROP FUNCTION${ifExistsStr} "${functionName}"${paramsStr}${cascadeStr};`;
+  };
+}
 
-export const createFunction = typeShorthands => {
+export function createFunction(typeShorthands) {
   const _create = (
     functionName,
     functionParams = [],
@@ -60,9 +58,9 @@ export const createFunction = typeShorthands => {
   _create.reverse = dropFunction(typeShorthands);
 
   return _create;
-};
+}
 
-export const renameFunction = typeShorthands => {
+export function renameFunction(typeShorthands) {
   const _rename = (oldFunctionName, functionParams = [], newFunctionName) => {
     const paramsStr = formatParams(functionParams, typeShorthands);
     return template`ALTER FUNCTION "${oldFunctionName}"${paramsStr} RENAME TO "${newFunctionName}";`;
@@ -72,4 +70,4 @@ export const renameFunction = typeShorthands => {
     _rename(newFunctionName, functionParams, oldFunctionName);
 
   return _rename;
-};
+}
diff --git a/lib/operations/indexes.js b/lib/operations/indexes.js
@@ -27,7 +27,7 @@ function generateColumnsString(columns) {
     : generateColumnString(columns);
 }
 
-export const createIndex = (tableName, columns, options = {}) => {
+export function createIndex(tableName, columns, options = {}) {
   /*
    columns - the column, columns, or expression to create the index on
 
@@ -48,17 +48,17 @@ export const createIndex = (tableName, columns, options = {}) => {
   const opclass = options.opclass ? ` ${options.opclass}` : "";
 
   return template`CREATE ${unique} INDEX ${concurrently} "${indexName}" ON "${tableName}"${method} (${columnsString}${opclass})${where};`;
-};
+}
 
-export const dropIndex = (tableName, columns, options = {}) => {
+export function dropIndex(tableName, columns, options = {}) {
   const { concurrently, ifExists, cascade } = options;
   const concurrentlyStr = concurrently ? " CONCURRENTLY" : "";
   const ifExistsStr = ifExists ? " IF EXISTS" : "";
   const indexName = generateIndexName(tableName, columns, options);
   const cascadeStr = cascade ? " CASCADE" : "";
 
   return `DROP INDEX${concurrentlyStr}${ifExistsStr} "${indexName}"${cascadeStr};`;
-};
+}
 
 // setup reverse functions
 createIndex.reverse = dropIndex;
diff --git a/lib/operations/operators.js b/lib/operations/operators.js
@@ -55,21 +55,21 @@ export const dropOperator = (operatorName, options = {}) => {
   return `DROP OPERATOR${ifExistsStr} ${operatorNameStr}(${leftStr}, ${rightStr})${cascadeStr};`;
 };
 
-export const createOperatorFamily = (operatorFamilyName, indexMethod) => {
+export function createOperatorFamily(operatorFamilyName, indexMethod) {
   const operatorFamilyNameStr = schemalize(operatorFamilyName);
   return `CREATE OPERATOR FAMILY ${operatorFamilyNameStr} USING ${indexMethod};`;
-};
+}
 
-export const dropOperatorFamily = (
+export function dropOperatorFamily(
   operatorFamilyName,
   indexMethod,
   { ifExists, cascade } = {}
-) => {
+) {
   const operatorFamilyNameStr = schemalize(operatorFamilyName);
   const ifExistsStr = ifExists ? " IF EXISTS" : "";
   const cascadeStr = cascade ? " CASCADE" : "";
   return `DROP OPERATOR FAMILY ${ifExistsStr} ${operatorFamilyNameStr} USING ${indexMethod}${cascadeStr};`;
-};
+}
 
 const operatorMap = typeShorthands => ({
   type = "",
@@ -118,16 +118,16 @@ export const addToOperatorFamily = changeOperatorFamily(
   removeFromOperatorFamily
 );
 
-export const renameOperatorFamily = (
+export function renameOperatorFamily(
   oldOperatorFamilyName,
   indexMethod,
   newOperatorFamilyName
-) => {
+) {
   const oldOperatorFamilyNameStr = schemalize(oldOperatorFamilyName);
   const newOperatorFamilyNameStr = schemalize(newOperatorFamilyName);
 
   return `ALTER OPERATOR FAMILY ${oldOperatorFamilyNameStr} USING ${indexMethod} RENAME TO ${newOperatorFamilyNameStr};`;
-};
+}
 
 const undoRenameOperatorFamily = (
   oldOperatorFamilyName,
@@ -140,19 +140,19 @@ const undoRenameOperatorFamily = (
     oldOperatorFamilyName
   );
 
-export const dropOperatorClass = (
+export function dropOperatorClass(
   operatorClassName,
   indexMethod,
   { ifExists, cascade } = {}
-) => {
+) {
   const operatorClassNameStr = schemalize(operatorClassName);
   const ifExistsStr = ifExists ? " IF EXISTS" : "";
   const cascadeStr = cascade ? " CASCADE" : "";
 
   return `DROP OPERATOR CLASS ${ifExistsStr} ${operatorClassNameStr} USING ${indexMethod}${cascadeStr};`;
-};
+}
 
-export const createOperatorClass = typeShorthands => {
+export function createOperatorClass(typeShorthands) {
   const _create = (
     operatorClassName,
     type,
@@ -181,18 +181,18 @@ export const createOperatorClass = typeShorthands => {
     options
   ) => dropOperatorClass(operatorClassName, indexMethod, options);
   return _create;
-};
+}
 
-export const renameOperatorClass = (
+export function renameOperatorClass(
   oldOperatorClassName,
   indexMethod,
   newOperatorClassName
-) => {
+) {
   const oldOperatorClassNameStr = schemalize(oldOperatorClassName);
   const newOperatorClassNameStr = schemalize(newOperatorClassName);
 
   return `ALTER OPERATOR CLASS ${oldOperatorClassNameStr} USING ${indexMethod} RENAME TO ${newOperatorClassNameStr};`;
-};
+}
 
 const undoRenameOperatorClass = (
   oldOperatorClassName,

diff --git a/lib/operations/other.js b/lib/operations/other.js
@@ -1,12 +1,12 @@
 import { t } from "../utils";
 
 // eslint-disable-next-line import/prefer-default-export
-export const sql = (...args) => {
+export function sql(...args) {
   // applies some very basic templating using the utils.p
   let s = t(...args);
   // add trailing ; if not present
   if (s.lastIndexOf(";") !== s.length - 1) {
     s += ";";
   }
   return s;
-};
+}
diff --git a/lib/operations/policies.js b/lib/operations/policies.js
@@ -15,7 +15,7 @@ const makeClauses = ({ role, using, check }) => {
   return clauses;
 };
 
-export const createPolicy = (tableName, policyName, options = {}) => {
+export function createPolicy(tableName, policyName, options = {}) {
   const createOptions = {
     ...options,
     role: options.role || "PUBLIC"
@@ -26,20 +26,21 @@ export const createPolicy = (tableName, policyName, options = {}) => {
   ];
   const clausesStr = clauses.join(" ");
   return template`CREATE POLICY "${policyName}" ON "${tableName}" ${clausesStr};`;
-};
+}
 
-export const alterPolicy = (tableName, policyName, options = {}) => {
+export function alterPolicy(tableName, policyName, options = {}) {
   const clausesStr = makeClauses(options).join(" ");
   return template`ALTER POLICY "${policyName}" ON "${tableName}" ${clausesStr};`;
-};
+}
 
-export const dropPolicy = (tableName, policyName, { ifExists } = {}) => {
+export function dropPolicy(tableName, policyName, { ifExists } = {}) {
   const ifExistsStr = ifExists ? " IF EXISTS" : "";
   return template`DROP POLICY${ifExistsStr} "${policyName}" ON "${tableName}";`;
-};
+}
 
-export const renamePolicy = (tableName, policyName, newPolicyName) =>
-  template`ALTER POLICY  "${policyName}" ON "${tableName}" RENAME TO "${newPolicyName}";`;
+export function renamePolicy(tableName, policyName, newPolicyName) {
+  return template`ALTER POLICY  "${policyName}" ON "${tableName}" RENAME TO "${newPolicyName}";`;
+}
 
 const undoRename = (tableName, policyName, newPolicyName) =>
   renamePolicy(tableName, newPolicyName, policyName);

diff --git a/lib/operations/roles.js b/lib/operations/roles.js
@@ -60,7 +60,7 @@ const formatRoleOptions = (roleOptions = {}) => {
   return options.join(" ");
 };
 
-export const createRole = (roleName, roleOptions = {}) => {
+export function createRole(roleName, roleOptions = {}) {
   const options = formatRoleOptions({
     ...roleOptions,
     superuser: roleOptions.superuser || false,
@@ -72,18 +72,20 @@ export const createRole = (roleName, roleOptions = {}) => {
   });
   const optionsStr = options ? ` WITH ${options}` : "";
   return template`CREATE ROLE "${roleName}"${optionsStr};`;
-};
+}
 
-export const dropRole = (roleName, { ifExists } = {}) =>
-  template`DROP ROLE${ifExists ? " IF EXISTS" : ""} "${roleName}";`;
+export function dropRole(roleName, { ifExists } = {}) {
+  return template`DROP ROLE${ifExists ? " IF EXISTS" : ""} "${roleName}";`;
+}
 
-export const alterRole = (roleName, roleOptions = {}) => {
+export function alterRole(roleName, roleOptions = {}) {
   const options = formatRoleOptions(roleOptions);
   return options ? template`ALTER ROLE "${roleName}" WITH ${options};` : "";
-};
+}
 
-export const renameRole = (oldRoleName, newRoleName) =>
-  template`ALTER ROLE "${oldRoleName}" RENAME TO "${newRoleName}";`;
+export function renameRole(oldRoleName, newRoleName) {
+  return template`ALTER ROLE "${oldRoleName}" RENAME TO "${newRoleName}";`;
+}
 
 const undoRename = (oldRoleName, newRoleName) =>
   renameRole(newRoleName, oldRoleName);

diff --git a/lib/operations/schemas.js b/lib/operations/schemas.js
@@ -1,24 +1,22 @@
 import { template } from "../utils";
 
-export const dropSchema = (schemaName, { ifExists, cascade } = {}) => {
+export function dropSchema(schemaName, { ifExists, cascade } = {}) {
   const ifExistsStr = ifExists ? " IF EXISTS" : "";
   const cascadeStr = cascade ? " CASCADE" : "";
   return template`DROP SCHEMA${ifExistsStr} "${schemaName}"${cascadeStr};`;
-};
+}
 
-export const createSchema = (
-  schemaName,
-  { ifNotExists, authorization } = {}
-) => {
+export function createSchema(schemaName, { ifNotExists, authorization } = {}) {
   const ifNotExistsStr = ifNotExists ? " IF NOT EXISTS" : "";
   const authorizationStr = authorization
     ? ` AUTHORIZATION ${authorization}`
     : "";
   return template`CREATE SCHEMA${ifNotExistsStr} "${schemaName}"${authorizationStr};`;
-};
+}
 
-export const renameSchema = (schemaName, newSchemaName) =>
-  template`ALTER SCHEMA  "${schemaName}" RENAME TO "${newSchemaName}";`;
+export function renameSchema(schemaName, newSchemaName) {
+  return template`ALTER SCHEMA  "${schemaName}" RENAME TO "${newSchemaName}";`;
+}
 
 const undoRename = (schemaName, newSchemaName) =>
   renameSchema(newSchemaName, schemaName);