@openfn/language-mssql 3.1.0 → 3.1.1

package/ast.json

@@ -663,6 +663,14 @@
               "name": "Function"
             },
             "name": "func"
+          },
+          {
+            "title": "returns",
+            "description": null,
+            "type": {
+              "type": "NameExpression",
+              "name": "Operation"
+            }
           }
         ]
       },
@@ -698,6 +706,14 @@
               "name": "String"
             },
             "name": "path"
+          },
+          {
+            "title": "returns",
+            "description": null,
+            "type": {
+              "type": "NameExpression",
+              "name": "Operation"
+            }
           }
         ]
       },
@@ -776,6 +792,14 @@
               "name": "String"
             },
             "name": "path"
+          },
+          {
+            "title": "returns",
+            "description": null,
+            "type": {
+              "type": "NameExpression",
+              "name": "Operation"
+            }
           }
         ]
       },
@@ -811,6 +835,14 @@
               "name": "String"
             },
             "name": "path"
+          },
+          {
+            "title": "returns",
+            "description": null,
+            "type": {
+              "type": "NameExpression",
+              "name": "Operation"
+            }
           }
         ]
       },
@@ -856,6 +888,14 @@
               "name": "Operation"
             },
             "name": "operation"
+          },
+          {
+            "title": "returns",
+            "description": null,
+            "type": {
+              "type": "NameExpression",
+              "name": "Operation"
+            }
           }
         ]
       },
@@ -944,6 +984,14 @@
               "name": "Value"
             },
             "name": "value"
+          },
+          {
+            "title": "returns",
+            "description": null,
+            "type": {
+              "type": "NameExpression",
+              "name": "Field"
+            }
           }
         ]
       },

package/dist/index.cjs

@@ -19,8 +19,31 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.js
 var src_exports = {};
 __export(src_exports, {
-  Adaptor: () => Adaptor_exports,
-  default: () => src_default
+  alterState: () => import_language_common2.alterState,
+  combine: () => import_language_common2.combine,
+  dataPath: () => import_language_common2.dataPath,
+  dataValue: () => import_language_common2.dataValue,
+  dateFns: () => import_language_common2.dateFns,
+  default: () => src_default,
+  describeTable: () => describeTable,
+  each: () => import_language_common2.each,
+  execute: () => execute,
+  field: () => import_language_common2.field,
+  fields: () => import_language_common2.fields,
+  findValue: () => findValue,
+  fn: () => import_language_common2.fn,
+  http: () => import_language_common2.http,
+  insert: () => insert,
+  insertMany: () => insertMany,
+  insertTable: () => insertTable,
+  lastReferenceValue: () => import_language_common2.lastReferenceValue,
+  merge: () => import_language_common2.merge,
+  modifyTable: () => modifyTable,
+  sourceValue: () => import_language_common2.sourceValue,
+  sql: () => sql,
+  upsert: () => upsert,
+  upsertIf: () => upsertIf,
+  upsertMany: () => upsertMany
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -517,5 +540,28 @@ function modifyTable(tableName, columns, options) {
 var src_default = Adaptor_exports;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Adaptor
+  alterState,
+  combine,
+  dataPath,
+  dataValue,
+  dateFns,
+  describeTable,
+  each,
+  execute,
+  field,
+  fields,
+  findValue,
+  fn,
+  http,
+  insert,
+  insertMany,
+  insertTable,
+  lastReferenceValue,
+  merge,
+  modifyTable,
+  sourceValue,
+  sql,
+  upsert,
+  upsertIf,
+  upsertMany
 });

package/dist/index.js

@@ -513,6 +513,29 @@ function modifyTable(tableName, columns, options) {
 // src/index.js
 var src_default = Adaptor_exports;
 export {
-  Adaptor_exports as Adaptor,
-  src_default as default
+  alterState,
+  combine,
+  dataPath,
+  dataValue,
+  dateFns,
+  src_default as default,
+  describeTable,
+  each,
+  execute,
+  field,
+  fields,
+  findValue,
+  fn,
+  http,
+  insert,
+  insertMany,
+  insertTable,
+  lastReferenceValue,
+  merge,
+  modifyTable,
+  sourceValue,
+  sql,
+  upsert,
+  upsertIf,
+  upsertMany
 };

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@openfn/language-mssql",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "A Microsoft SQL language pack for OpenFn",
-  "main": "dist/index.cjs",
+  "exports": {
+    "import": "./dist/index.js",
+    "require": "./dist/index.cjs"
+  },
   "homepage": "https://docs.openfn.org",
   "repository": {
     "type": "git",
@@ -17,29 +20,28 @@
     "configuration-schema.json"
   ],
   "dependencies": {
-    "@openfn/language-common": "1.6.2",
+    "@openfn/language-common": "1.7.4",
     "request": "2.88.0",
     "tedious": "15.1.0"
   },
   "devDependencies": {
+    "@openfn/buildtools": "^1.0.2",
     "@openfn/simple-ast": "0.4.1",
-    "assertion-error": "1.1.0",
-    "chai": "3.5.0",
-    "deep-eql": "0.1.3",
+    "assertion-error": "2.0.0",
+    "chai": "4.3.6",
+    "deep-eql": "4.1.1",
+    "esno": "^0.16.3",
     "mocha": "10.1.0",
-    "sinon": "1.17.7",
-    "superagent-mock": "4.0.0",
-    "esno": "0.16.3",
-    "rimraf": "3.0.2",
-    "@openfn/buildtools": "^1.0.0"
+    "rimraf": "3.0.2"
   },
   "type": "module",
   "types": "types/index.d.ts",
+  "main": "dist/index.cjs",
   "scripts": {
     "build": "pnpm clean && build-adaptor mssql",
     "test": "mocha --experimental-specifier-resolution=node --no-warnings",
     "test:watch": "mocha -w --experimental-specifier-resolution=node --no-warnings",
-    "clean": "rm -rf dist types docs",
+    "clean": "rimraf dist types docs",
     "pack": "pnpm pack --pack-destination ../../dist"
   }
 }

package/types/Adaptor.d.ts

@@ -0,0 +1,349 @@
+/**
+ * Execute a sequence of operations.
+ * Wraps `language-common/execute`, and prepends initial state for mssql.
+ * @example
+ * execute(
+ *   create('foo'),
+ *   delete('bar')
+ * )(state)
+ * @constructor
+ * @param {Operations} operations - Operations to be performed.
+ * @returns {Operation}
+ */
+export function execute(...operations: Operations): Operation;
+export class execute {
+    /**
+     * Execute a sequence of operations.
+     * Wraps `language-common/execute`, and prepends initial state for mssql.
+     * @example
+     * execute(
+     *   create('foo'),
+     *   delete('bar')
+     * )(state)
+     * @constructor
+     * @param {Operations} operations - Operations to be performed.
+     * @returns {Operation}
+     */
+    constructor(...operations: Operations);
+}
+/**
+ * Execute an SQL statement
+ * @public
+ * @example
+ * sql({ query, options })
+ * @constructor
+ * @param {object} params - Payload data for the message
+ * @returns {Operation}
+ */
+export function sql(params: object): Operation;
+export class sql {
+    /**
+     * Execute an SQL statement
+     * @public
+     * @example
+     * sql({ query, options })
+     * @constructor
+     * @param {object} params - Payload data for the message
+     * @returns {Operation}
+     */
+    constructor(params: object);
+}
+/**
+ * Fetch a uuid key given a condition
+ * @public
+ * @example
+ * findValue({
+ *    uuid: 'id',
+ *    relation: 'users',
+ *    where: { first_name: 'Mama%', last_name: 'Cisse'},
+ *    operator: { first_name: 'like', last_name: '='}
+ *  })
+ * @constructor
+ * @param {object} filter - A filter object with the lookup table, a uuid and the condition
+ * @returns {Operation}
+ */
+export function findValue(filter: object): Operation;
+export class findValue {
+    /**
+     * Fetch a uuid key given a condition
+     * @public
+     * @example
+     * findValue({
+     *    uuid: 'id',
+     *    relation: 'users',
+     *    where: { first_name: 'Mama%', last_name: 'Cisse'},
+     *    operator: { first_name: 'like', last_name: '='}
+     *  })
+     * @constructor
+     * @param {object} filter - A filter object with the lookup table, a uuid and the condition
+     * @returns {Operation}
+     */
+    constructor(filter: object);
+}
+/**
+ * Insert a record
+ * @public
+ * @example
+ * insert(table, record, {setNull: ["'undefined'", "''"], logValues: false})
+ * @constructor
+ * @param {string} table - The target table
+ * @param {object} record - Payload data for the record as a JS object
+ * @param {object} options - Optional options argument
+ * @returns {Operation}
+ */
+export function insert(table: string, record: object, options: object): Operation;
+export class insert {
+    /**
+     * Insert a record
+     * @public
+     * @example
+     * insert(table, record, {setNull: ["'undefined'", "''"], logValues: false})
+     * @constructor
+     * @param {string} table - The target table
+     * @param {object} record - Payload data for the record as a JS object
+     * @param {object} options - Optional options argument
+     * @returns {Operation}
+     */
+    constructor(table: string, record: object, options: object);
+}
+/**
+ * Insert many records, using the keys of the first as the column template
+ * @public
+ * @example
+ * insertMany(table, records, { setNull: false, writeSql: true, logValues: false })
+ * @constructor
+ * @param {string} table - The target table
+ * @param {function} records - A function that takes state and returns an array of records
+ * @param {object} options - Optional options argument
+ * @returns {Operation}
+ */
+export function insertMany(table: string, records: Function, options: object): Operation;
+export class insertMany {
+    /**
+     * Insert many records, using the keys of the first as the column template
+     * @public
+     * @example
+     * insertMany(table, records, { setNull: false, writeSql: true, logValues: false })
+     * @constructor
+     * @param {string} table - The target table
+     * @param {function} records - A function that takes state and returns an array of records
+     * @param {object} options - Optional options argument
+     * @returns {Operation}
+     */
+    constructor(table: string, records: Function, options: object);
+}
+/**
+ * Insert or update a record using SQL MERGE
+ * @public
+ * @example
+ * upsert(table, uuid, record, { setNull: "'undefined'", logValues: false})
+ * upsert(table, [uuid1, uuid2], record, { setNull: "'undefined'", logValues: false})
+ * @constructor
+ * @param {string} table - The target table
+ * @param {string} uuid - The uuid column to determine a matching/existing record
+ * @param {object} record - Payload data for the record as a JS object
+ * @param {object} options - Optional options argument
+ * @returns {Operation}
+ */
+export function upsert(table: string, uuid: string, record: object, options: object): Operation;
+export class upsert {
+    /**
+     * Insert or update a record using SQL MERGE
+     * @public
+     * @example
+     * upsert(table, uuid, record, { setNull: "'undefined'", logValues: false})
+     * upsert(table, [uuid1, uuid2], record, { setNull: "'undefined'", logValues: false})
+     * @constructor
+     * @param {string} table - The target table
+     * @param {string} uuid - The uuid column to determine a matching/existing record
+     * @param {object} record - Payload data for the record as a JS object
+     * @param {object} options - Optional options argument
+     * @returns {Operation}
+     */
+    constructor(table: string, uuid: string, record: object, options: object);
+}
+/**
+ * Insert or update a record based on a logical condition using ON CONFLICT UPDATE
+ * @public
+ * @example
+ * upsertIf(
+ *   dataValue('name'),
+ *   'users', // the DB table
+ *   'uuid', // a DB column with a unique constraint
+ *   { name: 'Elodie', id: 7 },
+ *   { writeSql:true, execute: true, logValues: false }
+ * )
+ * @constructor
+ * @param {string} logical - a data to check existing value for.
+ * @param {string} table - The target table
+ * @param {string} uuid - The uuid column to determine a matching/existing record
+ * @param {object} record - Payload data for the record as a JS object or function
+ * @param {object} options - Optional options argument
+ * @returns {Operation}
+ */
+export function upsertIf(logical: string, table: string, uuid: string, record: object, options: object): Operation;
+export class upsertIf {
+    /**
+     * Insert or update a record based on a logical condition using ON CONFLICT UPDATE
+     * @public
+     * @example
+     * upsertIf(
+     *   dataValue('name'),
+     *   'users', // the DB table
+     *   'uuid', // a DB column with a unique constraint
+     *   { name: 'Elodie', id: 7 },
+     *   { writeSql:true, execute: true, logValues: false }
+     * )
+     * @constructor
+     * @param {string} logical - a data to check existing value for.
+     * @param {string} table - The target table
+     * @param {string} uuid - The uuid column to determine a matching/existing record
+     * @param {object} record - Payload data for the record as a JS object or function
+     * @param {object} options - Optional options argument
+     * @returns {Operation}
+     */
+    constructor(logical: string, table: string, uuid: string, record: object, options: object);
+}
+/**
+ * Insert or update multiple records using ON CONFLICT UPDATE and excluded
+ * @public
+ * @example
+ * upsertMany(
+ *  'users', 'email', records, { logValues: false }
+ * )
+ * upsertMany(
+ *  'users', ['email', 'phone'], records, { logValues: false }
+ * )
+ * @constructor
+ * @param {string} table - The target table
+ * @param {string} uuid - The uuid column to determine a matching/existing record
+ * @param {function} records - A function that takes state and returns an array of records
+ * @param {object} options - Optional options argument
+ * @returns {Operation}
+ */
+export function upsertMany(table: string, uuid: string, records: Function, options: object): Operation;
+export class upsertMany {
+    /**
+     * Insert or update multiple records using ON CONFLICT UPDATE and excluded
+     * @public
+     * @example
+     * upsertMany(
+     *  'users', 'email', records, { logValues: false }
+     * )
+     * upsertMany(
+     *  'users', ['email', 'phone'], records, { logValues: false }
+     * )
+     * @constructor
+     * @param {string} table - The target table
+     * @param {string} uuid - The uuid column to determine a matching/existing record
+     * @param {function} records - A function that takes state and returns an array of records
+     * @param {object} options - Optional options argument
+     * @returns {Operation}
+     */
+    constructor(table: string, uuid: string, records: Function, options: object);
+}
+/**
+ * List the columns of a table in a database.
+ * @public
+ * @example
+ * describeTable('clinic_visits')
+ * @constructor
+ * @param {string} tableName - The name of the table to describe
+ * @param {object} options - Optional options argument
+ * @returns {Operation}
+ */
+export function describeTable(tableName: string, options: object): Operation;
+export class describeTable {
+    /**
+     * List the columns of a table in a database.
+     * @public
+     * @example
+     * describeTable('clinic_visits')
+     * @constructor
+     * @param {string} tableName - The name of the table to describe
+     * @param {object} options - Optional options argument
+     * @returns {Operation}
+     */
+    constructor(tableName: string, options: object);
+}
+/**
+ * Create a table in database when given an array of columns and a table_name.
+ * @public
+ * @example
+ * insertTable('table_name', state => state.data.map(
+ *   column => ({
+ *     name: column.name,
+ *     type: column.type,
+ *     required: true, // optional
+ *     unique: false, // optional - to be set to true for unique constraint
+ *   })
+ * ));
+ * @constructor
+ * @param {string} tableName - The name of the table to create
+ * @param {array} columns - An array of form columns
+ * @param {object} options - Optional options argument
+ * @returns {Operation}
+ */
+export function insertTable(tableName: string, columns: any[], options: object): Operation;
+export class insertTable {
+    /**
+     * Create a table in database when given an array of columns and a table_name.
+     * @public
+     * @example
+     * insertTable('table_name', state => state.data.map(
+     *   column => ({
+     *     name: column.name,
+     *     type: column.type,
+     *     required: true, // optional
+     *     unique: false, // optional - to be set to true for unique constraint
+     *   })
+     * ));
+     * @constructor
+     * @param {string} tableName - The name of the table to create
+     * @param {array} columns - An array of form columns
+     * @param {object} options - Optional options argument
+     * @returns {Operation}
+     */
+    constructor(tableName: string, columns: any[], options: object);
+}
+/**
+ * Alter an existing table in the database.
+ * @public
+ * @example
+ * modifyTable('table_name', state => state.data.map(
+ *   newColumn => ({
+ *     name: newColumn.name,
+ *     type: newColumn.type,
+ *     required: true, // optional
+ *     unique: false, // optional - to be set to true for unique constraint
+ *   })
+ * ));
+ * @constructor
+ * @param {string} tableName - The name of the table to alter
+ * @param {array} columns - An array of form columns
+ * @param {object} options - Optional options argument
+ * @returns {Operation}
+ */
+export function modifyTable(tableName: string, columns: any[], options: object): Operation;
+export class modifyTable {
+    /**
+     * Alter an existing table in the database.
+     * @public
+     * @example
+     * modifyTable('table_name', state => state.data.map(
+     *   newColumn => ({
+     *     name: newColumn.name,
+     *     type: newColumn.type,
+     *     required: true, // optional
+     *     unique: false, // optional - to be set to true for unique constraint
+     *   })
+     * ));
+     * @constructor
+     * @param {string} tableName - The name of the table to alter
+     * @param {array} columns - An array of form columns
+     * @param {object} options - Optional options argument
+     * @returns {Operation}
+     */
+    constructor(tableName: string, columns: any[], options: object);
+}
+export { alterState, combine, dataPath, dataValue, dateFns, each, field, fields, fn, http, lastReferenceValue, merge, sourceValue } from "@openfn/language-common";

package/types/index.d.ts

@@ -1,388 +1,3 @@
-/**
- * Execute a sequence of operations.
- * Wraps `language-common/execute`, and prepends initial state for mssql.
- * @example
- * execute(
- *   create('foo'),
- *   delete('bar')
- * )(state)
- * @constructor
- * @param {Operations} operations - Operations to be performed.
- * @returns {Operation}
- */
-declare function execute(...operations: Operations): Operation;
-declare class execute {
-    /**
-     * Execute a sequence of operations.
-     * Wraps `language-common/execute`, and prepends initial state for mssql.
-     * @example
-     * execute(
-     *   create('foo'),
-     *   delete('bar')
-     * )(state)
-     * @constructor
-     * @param {Operations} operations - Operations to be performed.
-     * @returns {Operation}
-     */
-    constructor(...operations: Operations);
-}
-/**
- * Execute an SQL statement
- * @public
- * @example
- * sql({ query, options })
- * @constructor
- * @param {object} params - Payload data for the message
- * @returns {Operation}
- */
-declare function sql(params: object): Operation;
-declare class sql {
-    /**
-     * Execute an SQL statement
-     * @public
-     * @example
-     * sql({ query, options })
-     * @constructor
-     * @param {object} params - Payload data for the message
-     * @returns {Operation}
-     */
-    constructor(params: object);
-}
-/**
- * Fetch a uuid key given a condition
- * @public
- * @example
- * findValue({
- *    uuid: 'id',
- *    relation: 'users',
- *    where: { first_name: 'Mama%', last_name: 'Cisse'},
- *    operator: { first_name: 'like', last_name: '='}
- *  })
- * @constructor
- * @param {object} filter - A filter object with the lookup table, a uuid and the condition
- * @returns {Operation}
- */
-declare function findValue(filter: object): Operation;
-declare class findValue {
-    /**
-     * Fetch a uuid key given a condition
-     * @public
-     * @example
-     * findValue({
-     *    uuid: 'id',
-     *    relation: 'users',
-     *    where: { first_name: 'Mama%', last_name: 'Cisse'},
-     *    operator: { first_name: 'like', last_name: '='}
-     *  })
-     * @constructor
-     * @param {object} filter - A filter object with the lookup table, a uuid and the condition
-     * @returns {Operation}
-     */
-    constructor(filter: object);
-}
-/**
- * Insert a record
- * @public
- * @example
- * insert(table, record, {setNull: ["'undefined'", "''"], logValues: false})
- * @constructor
- * @param {string} table - The target table
- * @param {object} record - Payload data for the record as a JS object
- * @param {object} options - Optional options argument
- * @returns {Operation}
- */
-declare function insert(table: string, record: object, options: object): Operation;
-declare class insert {
-    /**
-     * Insert a record
-     * @public
-     * @example
-     * insert(table, record, {setNull: ["'undefined'", "''"], logValues: false})
-     * @constructor
-     * @param {string} table - The target table
-     * @param {object} record - Payload data for the record as a JS object
-     * @param {object} options - Optional options argument
-     * @returns {Operation}
-     */
-    constructor(table: string, record: object, options: object);
-}
-/**
- * Insert many records, using the keys of the first as the column template
- * @public
- * @example
- * insertMany(table, records, { setNull: false, writeSql: true, logValues: false })
- * @constructor
- * @param {string} table - The target table
- * @param {function} records - A function that takes state and returns an array of records
- * @param {object} options - Optional options argument
- * @returns {Operation}
- */
-declare function insertMany(table: string, records: Function, options: object): Operation;
-declare class insertMany {
-    /**
-     * Insert many records, using the keys of the first as the column template
-     * @public
-     * @example
-     * insertMany(table, records, { setNull: false, writeSql: true, logValues: false })
-     * @constructor
-     * @param {string} table - The target table
-     * @param {function} records - A function that takes state and returns an array of records
-     * @param {object} options - Optional options argument
-     * @returns {Operation}
-     */
-    constructor(table: string, records: Function, options: object);
-}
-/**
- * Insert or update a record using SQL MERGE
- * @public
- * @example
- * upsert(table, uuid, record, { setNull: "'undefined'", logValues: false})
- * upsert(table, [uuid1, uuid2], record, { setNull: "'undefined'", logValues: false})
- * @constructor
- * @param {string} table - The target table
- * @param {string} uuid - The uuid column to determine a matching/existing record
- * @param {object} record - Payload data for the record as a JS object
- * @param {object} options - Optional options argument
- * @returns {Operation}
- */
-declare function upsert(table: string, uuid: string, record: object, options: object): Operation;
-declare class upsert {
-    /**
-     * Insert or update a record using SQL MERGE
-     * @public
-     * @example
-     * upsert(table, uuid, record, { setNull: "'undefined'", logValues: false})
-     * upsert(table, [uuid1, uuid2], record, { setNull: "'undefined'", logValues: false})
-     * @constructor
-     * @param {string} table - The target table
-     * @param {string} uuid - The uuid column to determine a matching/existing record
-     * @param {object} record - Payload data for the record as a JS object
-     * @param {object} options - Optional options argument
-     * @returns {Operation}
-     */
-    constructor(table: string, uuid: string, record: object, options: object);
-}
-/**
- * Insert or update a record based on a logical condition using ON CONFLICT UPDATE
- * @public
- * @example
- * upsertIf(
- *   dataValue('name'),
- *   'users', // the DB table
- *   'uuid', // a DB column with a unique constraint
- *   { name: 'Elodie', id: 7 },
- *   { writeSql:true, execute: true, logValues: false }
- * )
- * @constructor
- * @param {string} logical - a data to check existing value for.
- * @param {string} table - The target table
- * @param {string} uuid - The uuid column to determine a matching/existing record
- * @param {object} record - Payload data for the record as a JS object or function
- * @param {object} options - Optional options argument
- * @returns {Operation}
- */
-declare function upsertIf(logical: string, table: string, uuid: string, record: object, options: object): Operation;
-declare class upsertIf {
-    /**
-     * Insert or update a record based on a logical condition using ON CONFLICT UPDATE
-     * @public
-     * @example
-     * upsertIf(
-     *   dataValue('name'),
-     *   'users', // the DB table
-     *   'uuid', // a DB column with a unique constraint
-     *   { name: 'Elodie', id: 7 },
-     *   { writeSql:true, execute: true, logValues: false }
-     * )
-     * @constructor
-     * @param {string} logical - a data to check existing value for.
-     * @param {string} table - The target table
-     * @param {string} uuid - The uuid column to determine a matching/existing record
-     * @param {object} record - Payload data for the record as a JS object or function
-     * @param {object} options - Optional options argument
-     * @returns {Operation}
-     */
-    constructor(logical: string, table: string, uuid: string, record: object, options: object);
-}
-/**
- * Insert or update multiple records using ON CONFLICT UPDATE and excluded
- * @public
- * @example
- * upsertMany(
- *  'users', 'email', records, { logValues: false }
- * )
- * upsertMany(
- *  'users', ['email', 'phone'], records, { logValues: false }
- * )
- * @constructor
- * @param {string} table - The target table
- * @param {string} uuid - The uuid column to determine a matching/existing record
- * @param {function} records - A function that takes state and returns an array of records
- * @param {object} options - Optional options argument
- * @returns {Operation}
- */
-declare function upsertMany(table: string, uuid: string, records: Function, options: object): Operation;
-declare class upsertMany {
-    /**
-     * Insert or update multiple records using ON CONFLICT UPDATE and excluded
-     * @public
-     * @example
-     * upsertMany(
-     *  'users', 'email', records, { logValues: false }
-     * )
-     * upsertMany(
-     *  'users', ['email', 'phone'], records, { logValues: false }
-     * )
-     * @constructor
-     * @param {string} table - The target table
-     * @param {string} uuid - The uuid column to determine a matching/existing record
-     * @param {function} records - A function that takes state and returns an array of records
-     * @param {object} options - Optional options argument
-     * @returns {Operation}
-     */
-    constructor(table: string, uuid: string, records: Function, options: object);
-}
-/**
- * List the columns of a table in a database.
- * @public
- * @example
- * describeTable('clinic_visits')
- * @constructor
- * @param {string} tableName - The name of the table to describe
- * @param {object} options - Optional options argument
- * @returns {Operation}
- */
-declare function describeTable(tableName: string, options: object): Operation;
-declare class describeTable {
-    /**
-     * List the columns of a table in a database.
-     * @public
-     * @example
-     * describeTable('clinic_visits')
-     * @constructor
-     * @param {string} tableName - The name of the table to describe
-     * @param {object} options - Optional options argument
-     * @returns {Operation}
-     */
-    constructor(tableName: string, options: object);
-}
-/**
- * Create a table in database when given an array of columns and a table_name.
- * @public
- * @example
- * insertTable('table_name', state => state.data.map(
- *   column => ({
- *     name: column.name,
- *     type: column.type,
- *     required: true, // optional
- *     unique: false, // optional - to be set to true for unique constraint
- *   })
- * ));
- * @constructor
- * @param {string} tableName - The name of the table to create
- * @param {array} columns - An array of form columns
- * @param {object} options - Optional options argument
- * @returns {Operation}
- */
-declare function insertTable(tableName: string, columns: any[], options: object): Operation;
-declare class insertTable {
-    /**
-     * Create a table in database when given an array of columns and a table_name.
-     * @public
-     * @example
-     * insertTable('table_name', state => state.data.map(
-     *   column => ({
-     *     name: column.name,
-     *     type: column.type,
-     *     required: true, // optional
-     *     unique: false, // optional - to be set to true for unique constraint
-     *   })
-     * ));
-     * @constructor
-     * @param {string} tableName - The name of the table to create
-     * @param {array} columns - An array of form columns
-     * @param {object} options - Optional options argument
-     * @returns {Operation}
-     */
-    constructor(tableName: string, columns: any[], options: object);
-}
-/**
- * Alter an existing table in the database.
- * @public
- * @example
- * modifyTable('table_name', state => state.data.map(
- *   newColumn => ({
- *     name: newColumn.name,
- *     type: newColumn.type,
- *     required: true, // optional
- *     unique: false, // optional - to be set to true for unique constraint
- *   })
- * ));
- * @constructor
- * @param {string} tableName - The name of the table to alter
- * @param {array} columns - An array of form columns
- * @param {object} options - Optional options argument
- * @returns {Operation}
- */
-declare function modifyTable(tableName: string, columns: any[], options: object): Operation;
-declare class modifyTable {
-    /**
-     * Alter an existing table in the database.
-     * @public
-     * @example
-     * modifyTable('table_name', state => state.data.map(
-     *   newColumn => ({
-     *     name: newColumn.name,
-     *     type: newColumn.type,
-     *     required: true, // optional
-     *     unique: false, // optional - to be set to true for unique constraint
-     *   })
-     * ));
-     * @constructor
-     * @param {string} tableName - The name of the table to alter
-     * @param {array} columns - An array of form columns
-     * @param {object} options - Optional options argument
-     * @returns {Operation}
-     */
-    constructor(tableName: string, columns: any[], options: object);
-}
-
-type Adaptor_execute = execute;
-declare const Adaptor_execute: typeof execute;
-type Adaptor_sql = sql;
-declare const Adaptor_sql: typeof sql;
-type Adaptor_findValue = findValue;
-declare const Adaptor_findValue: typeof findValue;
-type Adaptor_insert = insert;
-declare const Adaptor_insert: typeof insert;
-type Adaptor_insertMany = insertMany;
-declare const Adaptor_insertMany: typeof insertMany;
-type Adaptor_upsert = upsert;
-declare const Adaptor_upsert: typeof upsert;
-type Adaptor_upsertIf = upsertIf;
-declare const Adaptor_upsertIf: typeof upsertIf;
-type Adaptor_upsertMany = upsertMany;
-declare const Adaptor_upsertMany: typeof upsertMany;
-type Adaptor_describeTable = describeTable;
-declare const Adaptor_describeTable: typeof describeTable;
-type Adaptor_insertTable = insertTable;
-declare const Adaptor_insertTable: typeof insertTable;
-type Adaptor_modifyTable = modifyTable;
-declare const Adaptor_modifyTable: typeof modifyTable;
-declare namespace Adaptor {
-  export {
-    Adaptor_execute as execute,
-    Adaptor_sql as sql,
-    Adaptor_findValue as findValue,
-    Adaptor_insert as insert,
-    Adaptor_insertMany as insertMany,
-    Adaptor_upsert as upsert,
-    Adaptor_upsertIf as upsertIf,
-    Adaptor_upsertMany as upsertMany,
-    Adaptor_describeTable as describeTable,
-    Adaptor_insertTable as insertTable,
-    Adaptor_modifyTable as modifyTable,
-  };
-}
-
-export { Adaptor, Adaptor as default };
+export default Adaptor;
+export * from "./Adaptor";
+import * as Adaptor from "./Adaptor";