@sqlanvil/cli 1.0.2 → 1.1.0

package/bundle.js

@@ -29,12 +29,12 @@ var childProcess = require('child_process');
 var fs = require('fs-extra');
 var tmp = require('tmp');
 var util = require('util');
+var pg = require('pg');
+var bigquery = require('@google-cloud/bigquery');
 var EventEmitter = require('events');
 var Long = require('long');
-var bigquery = require('@google-cloud/bigquery');
 var promisePoolExecutor = require('promise-pool-executor');
 var sizeof = require('object-sizeof');
-var pg = require('pg');
 var QueryStream = require('pg-query-stream');
 var readlineSync = require('readline-sync');
 var untildify = require('untildify');
@@ -74,10 +74,10 @@ var semver__namespace = /*#__PURE__*/_interopNamespace(semver);
 var childProcess__namespace = /*#__PURE__*/_interopNamespace(childProcess);
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var tmp__namespace = /*#__PURE__*/_interopNamespace(tmp);
+var pg__namespace = /*#__PURE__*/_interopNamespace(pg);
 var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
 var Long__default = /*#__PURE__*/_interopDefaultLegacy(Long);
 var sizeof__default = /*#__PURE__*/_interopDefaultLegacy(sizeof);
-var pg__namespace = /*#__PURE__*/_interopNamespace(pg);
 var QueryStream__default = /*#__PURE__*/_interopDefaultLegacy(QueryStream);
 var readlineSync__namespace = /*#__PURE__*/_interopNamespace(readlineSync);
 var untildify__default = /*#__PURE__*/_interopDefaultLegacy(untildify);
@@ -144,6 +144,7 @@ const sqlanvil = $root.sqlanvil = (() => {
          * @property {sqlanvil.IExtension|null} [extension] WorkflowSettings extension
          * @property {boolean|null} [includeTestsInCompiledGraph] WorkflowSettings includeTestsInCompiledGraph
          * @property {string|null} [warehouse] WorkflowSettings warehouse
+         * @property {Object.<string,sqlanvil.IConnectionConfig>|null} [connections] WorkflowSettings connections
          */
 
         /**
@@ -156,6 +157,7 @@ const sqlanvil = $root.sqlanvil = (() => {
          */
         function WorkflowSettings(properties) {
             this.vars = {};
+            this.connections = {};
             if (properties)
                 for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                     if (properties[keys[i]] != null)
@@ -298,6 +300,14 @@ const sqlanvil = $root.sqlanvil = (() => {
          */
         WorkflowSettings.prototype.warehouse = "";
 
+        /**
+         * WorkflowSettings connections.
+         * @member {Object.<string,sqlanvil.IConnectionConfig>} connections
+         * @memberof sqlanvil.WorkflowSettings
+         * @instance
+         */
+        WorkflowSettings.prototype.connections = $util.emptyObject;
+
         /**
          * Creates a new WorkflowSettings instance using the specified properties.
          * @function create
@@ -357,6 +367,11 @@ const sqlanvil = $root.sqlanvil = (() => {
                 writer.uint32(/* id 16, wireType 0 =*/128).bool(message.includeTestsInCompiledGraph);
             if (message.warehouse != null && Object.hasOwnProperty.call(message, "warehouse"))
                 writer.uint32(/* id 17, wireType 2 =*/138).string(message.warehouse);
+            if (message.connections != null && Object.hasOwnProperty.call(message, "connections"))
+                for (let keys = Object.keys(message.connections), i = 0; i < keys.length; ++i) {
+                    writer.uint32(/* id 18, wireType 2 =*/146).fork().uint32(/* id 1, wireType 2 =*/10).string(keys[i]);
+                    $root.sqlanvil.ConnectionConfig.encode(message.connections[keys[i]], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim().ldelim();
+                }
             return writer;
         };
 
@@ -480,6 +495,29 @@ const sqlanvil = $root.sqlanvil = (() => {
                         message.warehouse = reader.string();
                         break;
                     }
+                case 18: {
+                        if (message.connections === $util.emptyObject)
+                            message.connections = {};
+                        let end2 = reader.uint32() + reader.pos;
+                        key = "";
+                        value = null;
+                        while (reader.pos < end2) {
+                            let tag2 = reader.uint32();
+                            switch (tag2 >>> 3) {
+                            case 1:
+                                key = reader.string();
+                                break;
+                            case 2:
+                                value = $root.sqlanvil.ConnectionConfig.decode(reader, reader.uint32());
+                                break;
+                            default:
+                                reader.skipType(tag2 & 7);
+                                break;
+                            }
+                        }
+                        message.connections[key] = value;
+                        break;
+                    }
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -577,6 +615,16 @@ const sqlanvil = $root.sqlanvil = (() => {
             if (message.warehouse != null && message.hasOwnProperty("warehouse"))
                 if (!$util.isString(message.warehouse))
                     return "warehouse: string expected";
+            if (message.connections != null && message.hasOwnProperty("connections")) {
+                if (!$util.isObject(message.connections))
+                    return "connections: object expected";
+                let key = Object.keys(message.connections);
+                for (let i = 0; i < key.length; ++i) {
+                    let error = $root.sqlanvil.ConnectionConfig.verify(message.connections[key[i]]);
+                    if (error)
+                        return "connections." + error;
+                }
+            }
             return null;
         };
 
@@ -640,6 +688,16 @@ const sqlanvil = $root.sqlanvil = (() => {
                 message.includeTestsInCompiledGraph = Boolean(object.includeTestsInCompiledGraph);
             if (object.warehouse != null)
                 message.warehouse = String(object.warehouse);
+            if (object.connections) {
+                if (typeof object.connections !== "object")
+                    throw TypeError(".sqlanvil.WorkflowSettings.connections: object expected");
+                message.connections = {};
+                for (let keys = Object.keys(object.connections), i = 0; i < keys.length; ++i) {
+                    if (typeof object.connections[keys[i]] !== "object")
+                        throw TypeError(".sqlanvil.WorkflowSettings.connections: object expected");
+                    message.connections[keys[i]] = $root.sqlanvil.ConnectionConfig.fromObject(object.connections[keys[i]]);
+                }
+            }
             return message;
         };
 
@@ -656,8 +714,10 @@ const sqlanvil = $root.sqlanvil = (() => {
             if (!options)
                 options = {};
             let object = {};
-            if (options.objects || options.defaults)
+            if (options.objects || options.defaults) {
                 object.vars = {};
+                object.connections = {};
+            }
             if (options.defaults) {
                 object.sqlanvilCoreVersion = "";
                 object.defaultProject = "";
@@ -714,6 +774,11 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.includeTestsInCompiledGraph = message.includeTestsInCompiledGraph;
             if (message.warehouse != null && message.hasOwnProperty("warehouse"))
                 object.warehouse = message.warehouse;
+            if (message.connections && (keys2 = Object.keys(message.connections)).length) {
+                object.connections = {};
+                for (let j = 0; j < keys2.length; ++j)
+                    object.connections[keys2[j]] = $root.sqlanvil.ConnectionConfig.toObject(message.connections[keys2[j]], options);
+            }
             return object;
         };
 
@@ -746,6 +811,373 @@ const sqlanvil = $root.sqlanvil = (() => {
         return WorkflowSettings;
     })();
 
+    sqlanvil.ConnectionConfig = (function() {
+
+        /**
+         * Properties of a ConnectionConfig.
+         * @memberof sqlanvil
+         * @interface IConnectionConfig
+         * @property {string|null} [platform] ConnectionConfig platform
+         * @property {string|null} [project] ConnectionConfig project
+         * @property {string|null} [dataset] ConnectionConfig dataset
+         * @property {string|null} [saKeyId] ConnectionConfig saKeyId
+         * @property {string|null} [host] ConnectionConfig host
+         * @property {number|null} [port] ConnectionConfig port
+         * @property {string|null} [database] ConnectionConfig database
+         * @property {string|null} [defaultSchema] ConnectionConfig defaultSchema
+         */
+
+        /**
+         * Constructs a new ConnectionConfig.
+         * @memberof sqlanvil
+         * @classdesc Represents a ConnectionConfig.
+         * @implements IConnectionConfig
+         * @constructor
+         * @param {sqlanvil.IConnectionConfig=} [properties] Properties to set
+         */
+        function ConnectionConfig(properties) {
+            if (properties)
+                for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null)
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * ConnectionConfig platform.
+         * @member {string} platform
+         * @memberof sqlanvil.ConnectionConfig
+         * @instance
+         */
+        ConnectionConfig.prototype.platform = "";
+
+        /**
+         * ConnectionConfig project.
+         * @member {string} project
+         * @memberof sqlanvil.ConnectionConfig
+         * @instance
+         */
+        ConnectionConfig.prototype.project = "";
+
+        /**
+         * ConnectionConfig dataset.
+         * @member {string} dataset
+         * @memberof sqlanvil.ConnectionConfig
+         * @instance
+         */
+        ConnectionConfig.prototype.dataset = "";
+
+        /**
+         * ConnectionConfig saKeyId.
+         * @member {string} saKeyId
+         * @memberof sqlanvil.ConnectionConfig
+         * @instance
+         */
+        ConnectionConfig.prototype.saKeyId = "";
+
+        /**
+         * ConnectionConfig host.
+         * @member {string} host
+         * @memberof sqlanvil.ConnectionConfig
+         * @instance
+         */
+        ConnectionConfig.prototype.host = "";
+
+        /**
+         * ConnectionConfig port.
+         * @member {number} port
+         * @memberof sqlanvil.ConnectionConfig
+         * @instance
+         */
+        ConnectionConfig.prototype.port = 0;
+
+        /**
+         * ConnectionConfig database.
+         * @member {string} database
+         * @memberof sqlanvil.ConnectionConfig
+         * @instance
+         */
+        ConnectionConfig.prototype.database = "";
+
+        /**
+         * ConnectionConfig defaultSchema.
+         * @member {string} defaultSchema
+         * @memberof sqlanvil.ConnectionConfig
+         * @instance
+         */
+        ConnectionConfig.prototype.defaultSchema = "";
+
+        /**
+         * Creates a new ConnectionConfig instance using the specified properties.
+         * @function create
+         * @memberof sqlanvil.ConnectionConfig
+         * @static
+         * @param {sqlanvil.IConnectionConfig=} [properties] Properties to set
+         * @returns {sqlanvil.ConnectionConfig} ConnectionConfig instance
+         */
+        ConnectionConfig.create = function create(properties) {
+            return new ConnectionConfig(properties);
+        };
+
+        /**
+         * Encodes the specified ConnectionConfig message. Does not implicitly {@link sqlanvil.ConnectionConfig.verify|verify} messages.
+         * @function encode
+         * @memberof sqlanvil.ConnectionConfig
+         * @static
+         * @param {sqlanvil.IConnectionConfig} message ConnectionConfig message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        ConnectionConfig.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            if (message.platform != null && Object.hasOwnProperty.call(message, "platform"))
+                writer.uint32(/* id 1, wireType 2 =*/10).string(message.platform);
+            if (message.project != null && Object.hasOwnProperty.call(message, "project"))
+                writer.uint32(/* id 2, wireType 2 =*/18).string(message.project);
+            if (message.dataset != null && Object.hasOwnProperty.call(message, "dataset"))
+                writer.uint32(/* id 3, wireType 2 =*/26).string(message.dataset);
+            if (message.saKeyId != null && Object.hasOwnProperty.call(message, "saKeyId"))
+                writer.uint32(/* id 4, wireType 2 =*/34).string(message.saKeyId);
+            if (message.host != null && Object.hasOwnProperty.call(message, "host"))
+                writer.uint32(/* id 5, wireType 2 =*/42).string(message.host);
+            if (message.port != null && Object.hasOwnProperty.call(message, "port"))
+                writer.uint32(/* id 6, wireType 0 =*/48).uint32(message.port);
+            if (message.database != null && Object.hasOwnProperty.call(message, "database"))
+                writer.uint32(/* id 7, wireType 2 =*/58).string(message.database);
+            if (message.defaultSchema != null && Object.hasOwnProperty.call(message, "defaultSchema"))
+                writer.uint32(/* id 8, wireType 2 =*/66).string(message.defaultSchema);
+            return writer;
+        };
+
+        /**
+         * Encodes the specified ConnectionConfig message, length delimited. Does not implicitly {@link sqlanvil.ConnectionConfig.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof sqlanvil.ConnectionConfig
+         * @static
+         * @param {sqlanvil.IConnectionConfig} message ConnectionConfig message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        ConnectionConfig.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes a ConnectionConfig message from the specified reader or buffer.
+         * @function decode
+         * @memberof sqlanvil.ConnectionConfig
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {sqlanvil.ConnectionConfig} ConnectionConfig
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        ConnectionConfig.decode = function decode(reader, length, error) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            let end = length === undefined ? reader.len : reader.pos + length, message = new $root.sqlanvil.ConnectionConfig();
+            while (reader.pos < end) {
+                let tag = reader.uint32();
+                if (tag === error)
+                    break;
+                switch (tag >>> 3) {
+                case 1: {
+                        message.platform = reader.string();
+                        break;
+                    }
+                case 2: {
+                        message.project = reader.string();
+                        break;
+                    }
+                case 3: {
+                        message.dataset = reader.string();
+                        break;
+                    }
+                case 4: {
+                        message.saKeyId = reader.string();
+                        break;
+                    }
+                case 5: {
+                        message.host = reader.string();
+                        break;
+                    }
+                case 6: {
+                        message.port = reader.uint32();
+                        break;
+                    }
+                case 7: {
+                        message.database = reader.string();
+                        break;
+                    }
+                case 8: {
+                        message.defaultSchema = reader.string();
+                        break;
+                    }
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Decodes a ConnectionConfig message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof sqlanvil.ConnectionConfig
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {sqlanvil.ConnectionConfig} ConnectionConfig
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        ConnectionConfig.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies a ConnectionConfig message.
+         * @function verify
+         * @memberof sqlanvil.ConnectionConfig
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        ConnectionConfig.verify = function verify(message) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (message.platform != null && message.hasOwnProperty("platform"))
+                if (!$util.isString(message.platform))
+                    return "platform: string expected";
+            if (message.project != null && message.hasOwnProperty("project"))
+                if (!$util.isString(message.project))
+                    return "project: string expected";
+            if (message.dataset != null && message.hasOwnProperty("dataset"))
+                if (!$util.isString(message.dataset))
+                    return "dataset: string expected";
+            if (message.saKeyId != null && message.hasOwnProperty("saKeyId"))
+                if (!$util.isString(message.saKeyId))
+                    return "saKeyId: string expected";
+            if (message.host != null && message.hasOwnProperty("host"))
+                if (!$util.isString(message.host))
+                    return "host: string expected";
+            if (message.port != null && message.hasOwnProperty("port"))
+                if (!$util.isInteger(message.port))
+                    return "port: integer expected";
+            if (message.database != null && message.hasOwnProperty("database"))
+                if (!$util.isString(message.database))
+                    return "database: string expected";
+            if (message.defaultSchema != null && message.hasOwnProperty("defaultSchema"))
+                if (!$util.isString(message.defaultSchema))
+                    return "defaultSchema: string expected";
+            return null;
+        };
+
+        /**
+         * Creates a ConnectionConfig message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof sqlanvil.ConnectionConfig
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {sqlanvil.ConnectionConfig} ConnectionConfig
+         */
+        ConnectionConfig.fromObject = function fromObject(object) {
+            if (object instanceof $root.sqlanvil.ConnectionConfig)
+                return object;
+            let message = new $root.sqlanvil.ConnectionConfig();
+            if (object.platform != null)
+                message.platform = String(object.platform);
+            if (object.project != null)
+                message.project = String(object.project);
+            if (object.dataset != null)
+                message.dataset = String(object.dataset);
+            if (object.saKeyId != null)
+                message.saKeyId = String(object.saKeyId);
+            if (object.host != null)
+                message.host = String(object.host);
+            if (object.port != null)
+                message.port = object.port >>> 0;
+            if (object.database != null)
+                message.database = String(object.database);
+            if (object.defaultSchema != null)
+                message.defaultSchema = String(object.defaultSchema);
+            return message;
+        };
+
+        /**
+         * Creates a plain object from a ConnectionConfig message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof sqlanvil.ConnectionConfig
+         * @static
+         * @param {sqlanvil.ConnectionConfig} message ConnectionConfig
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        ConnectionConfig.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            let object = {};
+            if (options.defaults) {
+                object.platform = "";
+                object.project = "";
+                object.dataset = "";
+                object.saKeyId = "";
+                object.host = "";
+                object.port = 0;
+                object.database = "";
+                object.defaultSchema = "";
+            }
+            if (message.platform != null && message.hasOwnProperty("platform"))
+                object.platform = message.platform;
+            if (message.project != null && message.hasOwnProperty("project"))
+                object.project = message.project;
+            if (message.dataset != null && message.hasOwnProperty("dataset"))
+                object.dataset = message.dataset;
+            if (message.saKeyId != null && message.hasOwnProperty("saKeyId"))
+                object.saKeyId = message.saKeyId;
+            if (message.host != null && message.hasOwnProperty("host"))
+                object.host = message.host;
+            if (message.port != null && message.hasOwnProperty("port"))
+                object.port = message.port;
+            if (message.database != null && message.hasOwnProperty("database"))
+                object.database = message.database;
+            if (message.defaultSchema != null && message.hasOwnProperty("defaultSchema"))
+                object.defaultSchema = message.defaultSchema;
+            return object;
+        };
+
+        /**
+         * Converts this ConnectionConfig to JSON.
+         * @function toJSON
+         * @memberof sqlanvil.ConnectionConfig
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        ConnectionConfig.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf__namespace.util.toJSONOptions);
+        };
+
+        /**
+         * Gets the default type url for ConnectionConfig
+         * @function getTypeUrl
+         * @memberof sqlanvil.ConnectionConfig
+         * @static
+         * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+         * @returns {string} The default type url
+         */
+        ConnectionConfig.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === undefined) {
+                typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/sqlanvil.ConnectionConfig";
+        };
+
+        return ConnectionConfig;
+    })();
+
     sqlanvil.DefaultIcebergConfig = (function() {
 
         /**
@@ -7579,6 +8011,8 @@ const sqlanvil = $root.sqlanvil = (() => {
              * @property {Array.<sqlanvil.ActionConfig.IColumnDescriptor>|null} [columns] DeclarationConfig columns
              * @property {string|null} [filename] DeclarationConfig filename
              * @property {Array.<string>|null} [tags] DeclarationConfig tags
+             * @property {string|null} [connection] DeclarationConfig connection
+             * @property {Object.<string,string>|null} [columnTypes] DeclarationConfig columnTypes
              */
 
             /**
@@ -7592,6 +8026,7 @@ const sqlanvil = $root.sqlanvil = (() => {
             function DeclarationConfig(properties) {
                 this.columns = [];
                 this.tags = [];
+                this.columnTypes = {};
                 if (properties)
                     for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                         if (properties[keys[i]] != null)
@@ -7654,6 +8089,22 @@ const sqlanvil = $root.sqlanvil = (() => {
              */
             DeclarationConfig.prototype.tags = $util.emptyArray;
 
+            /**
+             * DeclarationConfig connection.
+             * @member {string} connection
+             * @memberof sqlanvil.ActionConfig.DeclarationConfig
+             * @instance
+             */
+            DeclarationConfig.prototype.connection = "";
+
+            /**
+             * DeclarationConfig columnTypes.
+             * @member {Object.<string,string>} columnTypes
+             * @memberof sqlanvil.ActionConfig.DeclarationConfig
+             * @instance
+             */
+            DeclarationConfig.prototype.columnTypes = $util.emptyObject;
+
             /**
              * Creates a new DeclarationConfig instance using the specified properties.
              * @function create
@@ -7694,6 +8145,11 @@ const sqlanvil = $root.sqlanvil = (() => {
                 if (message.tags != null && message.tags.length)
                     for (let i = 0; i < message.tags.length; ++i)
                         writer.uint32(/* id 7, wireType 2 =*/58).string(message.tags[i]);
+                if (message.connection != null && Object.hasOwnProperty.call(message, "connection"))
+                    writer.uint32(/* id 8, wireType 2 =*/66).string(message.connection);
+                if (message.columnTypes != null && Object.hasOwnProperty.call(message, "columnTypes"))
+                    for (let keys = Object.keys(message.columnTypes), i = 0; i < keys.length; ++i)
+                        writer.uint32(/* id 9, wireType 2 =*/74).fork().uint32(/* id 1, wireType 2 =*/10).string(keys[i]).uint32(/* id 2, wireType 2 =*/18).string(message.columnTypes[keys[i]]).ldelim();
                 return writer;
             };
 
@@ -7724,7 +8180,7 @@ const sqlanvil = $root.sqlanvil = (() => {
             DeclarationConfig.decode = function decode(reader, length, error) {
                 if (!(reader instanceof $Reader))
                     reader = $Reader.create(reader);
-                let end = length === undefined ? reader.len : reader.pos + length, message = new $root.sqlanvil.ActionConfig.DeclarationConfig();
+                let end = length === undefined ? reader.len : reader.pos + length, message = new $root.sqlanvil.ActionConfig.DeclarationConfig(), key, value;
                 while (reader.pos < end) {
                     let tag = reader.uint32();
                     if (tag === error)
@@ -7762,6 +8218,33 @@ const sqlanvil = $root.sqlanvil = (() => {
                             message.tags.push(reader.string());
                             break;
                         }
+                    case 8: {
+                            message.connection = reader.string();
+                            break;
+                        }
+                    case 9: {
+                            if (message.columnTypes === $util.emptyObject)
+                                message.columnTypes = {};
+                            let end2 = reader.uint32() + reader.pos;
+                            key = "";
+                            value = "";
+                            while (reader.pos < end2) {
+                                let tag2 = reader.uint32();
+                                switch (tag2 >>> 3) {
+                                case 1:
+                                    key = reader.string();
+                                    break;
+                                case 2:
+                                    value = reader.string();
+                                    break;
+                                default:
+                                    reader.skipType(tag2 & 7);
+                                    break;
+                                }
+                            }
+                            message.columnTypes[key] = value;
+                            break;
+                        }
                     default:
                         reader.skipType(tag & 7);
                         break;
@@ -7828,6 +8311,17 @@ const sqlanvil = $root.sqlanvil = (() => {
                         if (!$util.isString(message.tags[i]))
                             return "tags: string[] expected";
                 }
+                if (message.connection != null && message.hasOwnProperty("connection"))
+                    if (!$util.isString(message.connection))
+                        return "connection: string expected";
+                if (message.columnTypes != null && message.hasOwnProperty("columnTypes")) {
+                    if (!$util.isObject(message.columnTypes))
+                        return "columnTypes: object expected";
+                    let key = Object.keys(message.columnTypes);
+                    for (let i = 0; i < key.length; ++i)
+                        if (!$util.isString(message.columnTypes[key[i]]))
+                            return "columnTypes: string{k:string} expected";
+                }
                 return null;
             };
 
@@ -7870,6 +8364,15 @@ const sqlanvil = $root.sqlanvil = (() => {
                     for (let i = 0; i < object.tags.length; ++i)
                         message.tags[i] = String(object.tags[i]);
                 }
+                if (object.connection != null)
+                    message.connection = String(object.connection);
+                if (object.columnTypes) {
+                    if (typeof object.columnTypes !== "object")
+                        throw TypeError(".sqlanvil.ActionConfig.DeclarationConfig.columnTypes: object expected");
+                    message.columnTypes = {};
+                    for (let keys = Object.keys(object.columnTypes), i = 0; i < keys.length; ++i)
+                        message.columnTypes[keys[i]] = String(object.columnTypes[keys[i]]);
+                }
                 return message;
             };
 
@@ -7890,12 +8393,15 @@ const sqlanvil = $root.sqlanvil = (() => {
                     object.columns = [];
                     object.tags = [];
                 }
+                if (options.objects || options.defaults)
+                    object.columnTypes = {};
                 if (options.defaults) {
                     object.name = "";
                     object.dataset = "";
                     object.project = "";
                     object.description = "";
                     object.filename = "";
+                    object.connection = "";
                 }
                 if (message.name != null && message.hasOwnProperty("name"))
                     object.name = message.name;
@@ -7917,6 +8423,14 @@ const sqlanvil = $root.sqlanvil = (() => {
                     for (let j = 0; j < message.tags.length; ++j)
                         object.tags[j] = message.tags[j];
                 }
+                if (message.connection != null && message.hasOwnProperty("connection"))
+                    object.connection = message.connection;
+                let keys2;
+                if (message.columnTypes && (keys2 = Object.keys(message.columnTypes)).length) {
+                    object.columnTypes = {};
+                    for (let j = 0; j < keys2.length; ++j)
+                        object.columnTypes[keys2[j]] = message.columnTypes[keys2[j]];
+                }
                 return object;
             };
 
@@ -15055,6 +15569,8 @@ const sqlanvil = $root.sqlanvil = (() => {
          * @property {boolean|null} [disableAssertions] ProjectConfig disableAssertions
          * @property {string|null} [defaultReservation] ProjectConfig defaultReservation
          * @property {boolean|null} [includeTestsInCompiledGraph] ProjectConfig includeTestsInCompiledGraph
+         * @property {Object.<string,sqlanvil.IConnectionConfig>|null} [connections] ProjectConfig connections
+         * @property {string|null} [warehouseConnection] ProjectConfig warehouseConnection
          */
 
         /**
@@ -15067,6 +15583,7 @@ const sqlanvil = $root.sqlanvil = (() => {
          */
         function ProjectConfig(properties) {
             this.vars = {};
+            this.connections = {};
             if (properties)
                 for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                     if (properties[keys[i]] != null)
@@ -15193,6 +15710,22 @@ const sqlanvil = $root.sqlanvil = (() => {
          */
         ProjectConfig.prototype.includeTestsInCompiledGraph = false;
 
+        /**
+         * ProjectConfig connections.
+         * @member {Object.<string,sqlanvil.IConnectionConfig>} connections
+         * @memberof sqlanvil.ProjectConfig
+         * @instance
+         */
+        ProjectConfig.prototype.connections = $util.emptyObject;
+
+        /**
+         * ProjectConfig warehouseConnection.
+         * @member {string} warehouseConnection
+         * @memberof sqlanvil.ProjectConfig
+         * @instance
+         */
+        ProjectConfig.prototype.warehouseConnection = "";
+
         /**
          * Creates a new ProjectConfig instance using the specified properties.
          * @function create
@@ -15248,6 +15781,13 @@ const sqlanvil = $root.sqlanvil = (() => {
                 writer.uint32(/* id 21, wireType 2 =*/170).string(message.defaultReservation);
             if (message.includeTestsInCompiledGraph != null && Object.hasOwnProperty.call(message, "includeTestsInCompiledGraph"))
                 writer.uint32(/* id 22, wireType 0 =*/176).bool(message.includeTestsInCompiledGraph);
+            if (message.connections != null && Object.hasOwnProperty.call(message, "connections"))
+                for (let keys = Object.keys(message.connections), i = 0; i < keys.length; ++i) {
+                    writer.uint32(/* id 23, wireType 2 =*/186).fork().uint32(/* id 1, wireType 2 =*/10).string(keys[i]);
+                    $root.sqlanvil.ConnectionConfig.encode(message.connections[keys[i]], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim().ldelim();
+                }
+            if (message.warehouseConnection != null && Object.hasOwnProperty.call(message, "warehouseConnection"))
+                writer.uint32(/* id 24, wireType 2 =*/194).string(message.warehouseConnection);
             return writer;
         };
 
@@ -15363,6 +15903,33 @@ const sqlanvil = $root.sqlanvil = (() => {
                         message.includeTestsInCompiledGraph = reader.bool();
                         break;
                     }
+                case 23: {
+                        if (message.connections === $util.emptyObject)
+                            message.connections = {};
+                        let end2 = reader.uint32() + reader.pos;
+                        key = "";
+                        value = null;
+                        while (reader.pos < end2) {
+                            let tag2 = reader.uint32();
+                            switch (tag2 >>> 3) {
+                            case 1:
+                                key = reader.string();
+                                break;
+                            case 2:
+                                value = $root.sqlanvil.ConnectionConfig.decode(reader, reader.uint32());
+                                break;
+                            default:
+                                reader.skipType(tag2 & 7);
+                                break;
+                            }
+                        }
+                        message.connections[key] = value;
+                        break;
+                    }
+                case 24: {
+                        message.warehouseConnection = reader.string();
+                        break;
+                    }
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -15452,6 +16019,19 @@ const sqlanvil = $root.sqlanvil = (() => {
             if (message.includeTestsInCompiledGraph != null && message.hasOwnProperty("includeTestsInCompiledGraph"))
                 if (typeof message.includeTestsInCompiledGraph !== "boolean")
                     return "includeTestsInCompiledGraph: boolean expected";
+            if (message.connections != null && message.hasOwnProperty("connections")) {
+                if (!$util.isObject(message.connections))
+                    return "connections: object expected";
+                let key = Object.keys(message.connections);
+                for (let i = 0; i < key.length; ++i) {
+                    let error = $root.sqlanvil.ConnectionConfig.verify(message.connections[key[i]]);
+                    if (error)
+                        return "connections." + error;
+                }
+            }
+            if (message.warehouseConnection != null && message.hasOwnProperty("warehouseConnection"))
+                if (!$util.isString(message.warehouseConnection))
+                    return "warehouseConnection: string expected";
             return null;
         };
 
@@ -15508,6 +16088,18 @@ const sqlanvil = $root.sqlanvil = (() => {
                 message.defaultReservation = String(object.defaultReservation);
             if (object.includeTestsInCompiledGraph != null)
                 message.includeTestsInCompiledGraph = Boolean(object.includeTestsInCompiledGraph);
+            if (object.connections) {
+                if (typeof object.connections !== "object")
+                    throw TypeError(".sqlanvil.ProjectConfig.connections: object expected");
+                message.connections = {};
+                for (let keys = Object.keys(object.connections), i = 0; i < keys.length; ++i) {
+                    if (typeof object.connections[keys[i]] !== "object")
+                        throw TypeError(".sqlanvil.ProjectConfig.connections: object expected");
+                    message.connections[keys[i]] = $root.sqlanvil.ConnectionConfig.fromObject(object.connections[keys[i]]);
+                }
+            }
+            if (object.warehouseConnection != null)
+                message.warehouseConnection = String(object.warehouseConnection);
             return message;
         };
 
@@ -15524,8 +16116,10 @@ const sqlanvil = $root.sqlanvil = (() => {
             if (!options)
                 options = {};
             let object = {};
-            if (options.objects || options.defaults)
+            if (options.objects || options.defaults) {
                 object.vars = {};
+                object.connections = {};
+            }
             if (options.defaults) {
                 object.warehouse = "";
                 object.defaultSchema = "";
@@ -15541,6 +16135,7 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.disableAssertions = false;
                 object.defaultReservation = "";
                 object.includeTestsInCompiledGraph = false;
+                object.warehouseConnection = "";
             }
             if (message.warehouse != null && message.hasOwnProperty("warehouse"))
                 object.warehouse = message.warehouse;
@@ -15576,6 +16171,13 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.defaultReservation = message.defaultReservation;
             if (message.includeTestsInCompiledGraph != null && message.hasOwnProperty("includeTestsInCompiledGraph"))
                 object.includeTestsInCompiledGraph = message.includeTestsInCompiledGraph;
+            if (message.connections && (keys2 = Object.keys(message.connections)).length) {
+                object.connections = {};
+                for (let j = 0; j < keys2.length; ++j)
+                    object.connections[keys2[j]] = $root.sqlanvil.ConnectionConfig.toObject(message.connections[keys2[j]], options);
+            }
+            if (message.warehouseConnection != null && message.hasOwnProperty("warehouseConnection"))
+                object.warehouseConnection = message.warehouseConnection;
             return object;
         };
 
@@ -38006,7 +38608,7 @@ function collectEvaluationQueries(queryOrAction, concatenate, queryModifier = (q
         .filter(validationQuery => !!validationQuery.query);
 }
 
-const version = "1.0.2";
+const version = "1.1.0";
 const dataformVersion = "3.0.59";
 
 async function build(compiledGraph, runConfig, dbadapter) {
@@ -38329,7 +38931,7 @@ async function init(projectDir, projectConfig) {
         fs__namespace$1.mkdirSync(projectDir);
         dirsCreated.push(projectDir);
     }
-    const warehouse = projectConfig.warehouse || "bigquery";
+    const warehouse = projectConfig.warehouse || "supabase";
     const isBigQuery = warehouse === "bigquery";
     const workflowSettings = {
         sqlanvilCoreVersion: version
@@ -38409,6 +39011,178 @@ async function init(projectDir, projectConfig) {
     };
 }
 
+const BIGQUERY_TYPE_MAP = {
+    STRING: "text",
+    BYTES: "bytea",
+    INT64: "bigint",
+    INTEGER: "bigint",
+    FLOAT64: "float8",
+    FLOAT: "float8",
+    NUMERIC: "numeric",
+    BIGNUMERIC: "numeric",
+    BOOL: "boolean",
+    BOOLEAN: "boolean",
+    TIMESTAMP: "timestamptz",
+    DATETIME: "timestamp",
+    DATE: "date",
+    TIME: "time",
+    JSON: "jsonb",
+    GEOGRAPHY: "text"
+};
+function mapBigQueryType(bqType) {
+    const key = bqType.trim().toUpperCase();
+    const mapped = BIGQUERY_TYPE_MAP[key];
+    if (!mapped) {
+        throw new Error(`Unmapped BigQuery type "${bqType}". Add it to BIGQUERY_TYPE_MAP or set the column type by hand.`);
+    }
+    return mapped;
+}
+function mapPostgresType(pgType) {
+    return pgType.trim().toLowerCase();
+}
+function keyToken(name) {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : `"${name}"`;
+}
+function quote(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function renderDeclarationSqlx(opts) {
+    const lines = [];
+    lines.push("config {");
+    lines.push(`  type: "declaration",`);
+    lines.push(`  connection: ${quote(opts.connection)},`);
+    if (opts.schema) {
+        lines.push(`  schema: ${quote(opts.schema)},`);
+    }
+    lines.push(`  name: ${quote(opts.name)},`);
+    const typeLines = opts.columns.map(function (c) { return `    ${keyToken(c.name)}: ${quote(c.type)}`; });
+    const described = opts.columns.filter(function (c) { return !!c.description; });
+    lines.push(`  columnTypes: {`);
+    lines.push(typeLines.join(",\n"));
+    lines.push(described.length > 0 ? `  },` : `  }`);
+    if (described.length > 0) {
+        const descLines = described.map(function (c) { return `    ${keyToken(c.name)}: ${quote(c.description)}`; });
+        lines.push(`  columns: {`);
+        lines.push(descLines.join(",\n"));
+        lines.push(`  }`);
+    }
+    lines.push("}");
+    return lines.join("\n") + "\n";
+}
+function resolveConnection(projectDir, connectionName) {
+    const workflowSettings = readConfigFromWorkflowSettings(path__namespace.resolve(projectDir));
+    const definition = workflowSettings && workflowSettings.connections
+        ? workflowSettings.connections[connectionName]
+        : undefined;
+    if (!definition) {
+        throw new Error(`Unknown connection "${connectionName}". Define it under \`connections:\` in workflow_settings.yaml.`);
+    }
+    const credsPath = path__namespace.join(path__namespace.resolve(projectDir), ".df-credentials.json");
+    if (!fs__namespace.existsSync(credsPath)) {
+        throw new Error(`Missing .df-credentials.json in ${projectDir}.`);
+    }
+    const allCreds = JSON.parse(fs__namespace.readFileSync(credsPath, "utf8"));
+    const credentials = allCreds[connectionName];
+    if (!credentials) {
+        throw new Error(`No credentials for connection "${connectionName}" in .df-credentials.json ` +
+            `(expected a top-level "${connectionName}" key).`);
+    }
+    return { name: connectionName, definition, credentials };
+}
+const readPostgresSchema = function (resolved, sourceSchema, table) {
+    const c = resolved.credentials;
+    const client = new pg__namespace.Client({
+        host: c.host || resolved.definition.host,
+        port: Number(c.port || resolved.definition.port || 5432),
+        database: c.database || resolved.definition.database,
+        user: c.user,
+        password: c.password,
+        ssl: c.sslMode && c.sslMode !== "disable" ? { rejectUnauthorized: false } : undefined
+    });
+    return client
+        .connect()
+        .then(function () {
+        return client.query(`select a.attname as column_name,
+                format_type(a.atttypid, a.atttypmod) as data_type,
+                col_description(a.attrelid, a.attnum) as description
+         from pg_attribute a
+         where a.attrelid = format('%I.%I', $1::text, $2::text)::regclass
+           and a.attnum > 0 and not a.attisdropped
+         order by a.attnum`, [sourceSchema, table]);
+    })
+        .then(function (res) {
+        return res.rows.map(function (r) {
+            return { name: r.column_name, type: r.data_type, description: r.description || undefined };
+        });
+    })
+        .then(function (cols) {
+        return client.end().then(function () {
+            return cols;
+        });
+    }, function (err) {
+        return client.end().then(function () { throw err; }, function () { throw err; });
+    });
+};
+const readBigQuerySchema = function (resolved, sourceSchema, table) {
+    const keyJson = resolved.credentials.credentials;
+    const bq = new bigquery.BigQuery({
+        projectId: resolved.definition.project,
+        credentials: typeof keyJson === "string" ? JSON.parse(keyJson) : keyJson
+    });
+    return bq
+        .dataset(sourceSchema)
+        .table(table)
+        .getMetadata()
+        .then(function (result) {
+        const metadata = result[0];
+        const fields = (metadata && metadata.schema && metadata.schema.fields) || [];
+        return fields.map(function (f) {
+            return { name: f.name, type: f.type, description: f.description || undefined };
+        });
+    });
+};
+function defaultReaderFor(platform) {
+    if (platform === "bigquery") {
+        return readBigQuerySchema;
+    }
+    if (platform === "postgres" || platform === "supabase") {
+        return readPostgresSchema;
+    }
+    throw new Error(`introspect does not support source platform "${platform}".`);
+}
+function splitTableRef(tableRef) {
+    const dot = tableRef.indexOf(".");
+    return dot === -1
+        ? { table: tableRef }
+        : { schema: tableRef.slice(0, dot), table: tableRef.slice(dot + 1) };
+}
+function introspectToSqlx(projectDir, connectionName, tableRef, options) {
+    const opts = options || {};
+    const resolved = resolveConnection(projectDir, connectionName);
+    const parts = splitTableRef(tableRef);
+    const reader = opts.reader || defaultReaderFor(resolved.definition.platform);
+    const sourceSchema = parts.schema || resolved.definition.dataset || resolved.definition.defaultSchema;
+    if (!sourceSchema) {
+        return Promise.reject(new Error(`Could not determine the source schema for "${tableRef}" on connection "${connectionName}". ` +
+            `Pass it as "schema.table", or set "dataset"/"defaultSchema" on the connection.`));
+    }
+    const mapType = resolved.definition.platform === "bigquery" ? mapBigQueryType : mapPostgresType;
+    return reader(resolved, sourceSchema, parts.table).then(function (rawColumns) {
+        if (rawColumns.length === 0) {
+            throw new Error(`Source table "${tableRef}" on connection "${connectionName}" has no columns (does it exist?).`);
+        }
+        const columns = rawColumns.map(function (col) {
+            return { name: col.name, type: mapType(col.type), description: col.description };
+        });
+        return renderDeclarationSqlx({
+            connection: connectionName,
+            schema: parts.schema,
+            name: parts.table,
+            columns
+        });
+    });
+}
+
 function parseArgvFlags(argv) {
     const parsedArgv = {};
     const splitArgv = [];
@@ -41263,7 +42037,7 @@ const warehouseOption = {
         describe: "Target warehouse for the new project.",
         type: "string",
         choices: ["bigquery", "postgres", "supabase"],
-        default: "bigquery"
+        default: "supabase"
     }
 };
 const testConnectionOptionName = "test-connection";
@@ -41765,6 +42539,42 @@ function runCli() {
                     }
                     return 0;
                 }
+            },
+            {
+                format: `introspect <connection> <tableRef> [${projectDirOption.name}]`,
+                description: "Read a source table's schema from a connection and write a declaration .sqlx with columnTypes.",
+                positionalOptions: [
+                    {
+                        name: "connection",
+                        option: { describe: "Connection name (from workflow_settings.yaml connections)." }
+                    },
+                    {
+                        name: "tableRef",
+                        option: { describe: "Source table as schema.table (or just table)." }
+                    },
+                    projectDirOption
+                ],
+                options: [
+                    {
+                        name: "output",
+                        option: {
+                            describe: "File to write the declaration .sqlx to. Prints to stdout if omitted.",
+                            type: "string"
+                        }
+                    }
+                ],
+                processFn: async (argv) => {
+                    const projectDir = argv[projectDirOption.name];
+                    const sqlx = await introspectToSqlx(projectDir, argv.connection, argv.tableRef);
+                    if (argv.output) {
+                        fs__namespace$1.writeFileSync(argv.output, sqlx);
+                        printSuccess(`Wrote declaration to ${argv.output}`);
+                    }
+                    else {
+                        print(sqlx);
+                    }
+                    return 0;
+                }
             }
         ]
     })