firebase-tools 13.7.5 → 13.8.1

package/lib/commands/dataconnect-sdk-generate.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const path = require("path");
+const command_1 = require("../command");
+const dataconnectEmulator_1 = require("../emulator/dataconnectEmulator");
+const projectUtils_1 = require("../projectUtils");
+const load_1 = require("../dataconnect/load");
+const fileUtils_1 = require("../dataconnect/fileUtils");
+const logger_1 = require("../logger");
+exports.command = new command_1.Command("dataconnect:sdk:generate")
+    .description("generates typed SDKs for your Data Connect connectors")
+    .action(async (options) => {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const services = (0, fileUtils_1.readFirebaseJson)(options.config);
+    for (const service of services) {
+        let configDir = service.source;
+        if (!path.isAbsolute(configDir)) {
+            const cwd = options.cwd || process.cwd();
+            configDir = path.resolve(path.join(cwd), configDir);
+        }
+        const serviceInfo = await (0, load_1.load)(projectId, service.location, configDir);
+        const args = {
+            projectId,
+            configDir,
+            auto_download: true,
+            rc: options.rc,
+            locationId: service.location,
+        };
+        const dataconnectEmulator = new dataconnectEmulator_1.DataConnectEmulator(args);
+        for (const conn of serviceInfo.connectorInfo) {
+            const output = await dataconnectEmulator.generate(conn.connectorYaml.connectorId);
+            logger_1.logger.info(output);
+            logger_1.logger.info(`Generated SDKs for ${conn.connectorYaml.connectorId}`);
+        }
+    }
+});

package/lib/commands/dataconnect-sql-diff.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const projectUtils_1 = require("../projectUtils");
+const ensureApis_1 = require("../dataconnect/ensureApis");
+const requirePermissions_1 = require("../requirePermissions");
+const fileUtils_1 = require("../dataconnect/fileUtils");
+const schemaMigration_1 = require("../dataconnect/schemaMigration");
+const requireAuth_1 = require("../requireAuth");
+exports.command = new command_1.Command("dataconnect:sql:diff [serviceId]")
+    .description("displays the differences between  a local DataConnect schema and your CloudSQL database's current schema")
+    .before(requirePermissions_1.requirePermissions, [
+    "firebasedataconnect.services.list",
+    "firebasedataconnect.schemas.list",
+    "firebasedataconnect.schemas.update",
+])
+    .before(requireAuth_1.requireAuth)
+    .action(async (serviceId, options) => {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    await (0, ensureApis_1.ensureApis)(projectId);
+    const serviceInfo = await (0, fileUtils_1.pickService)(projectId, options.config, serviceId);
+    const diffs = await (0, schemaMigration_1.diffSchema)(serviceInfo.schema);
+    return { projectId, serviceId, diffs };
+});

package/lib/commands/dataconnect-sql-migrate.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const projectUtils_1 = require("../projectUtils");
+const fileUtils_1 = require("../dataconnect/fileUtils");
+const logger_1 = require("../logger");
+const error_1 = require("../error");
+const schemaMigration_1 = require("../dataconnect/schemaMigration");
+const requireAuth_1 = require("../requireAuth");
+const requirePermissions_1 = require("../requirePermissions");
+const ensureApis_1 = require("../dataconnect/ensureApis");
+exports.command = new command_1.Command("dataconnect:sql:migrate [serviceId]")
+    .description("migrates your CloudSQL database's schema to match your local DataConnect schema")
+    .before(requirePermissions_1.requirePermissions, [
+    "firebasedataconnect.services.list",
+    "firebasedataconnect.schemas.list",
+    "firebasedataconnect.schemas.update",
+    "cloudsql.instances.connect",
+    "cloudsql.users.create",
+])
+    .before(requireAuth_1.requireAuth)
+    .withForce("Execute any required database changes without prompting")
+    .action(async (serviceId, options) => {
+    var _a;
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    await (0, ensureApis_1.ensureApis)(projectId);
+    const serviceInfo = await (0, fileUtils_1.pickService)(projectId, options.config, serviceId);
+    const instanceId = (_a = serviceInfo.dataConnectYaml.schema.datasource.postgresql) === null || _a === void 0 ? void 0 : _a.cloudSql.instanceId;
+    if (!instanceId) {
+        throw new error_1.FirebaseError("dataconnect.yaml is missing field schema.datasource.postgresql.cloudsql.instanceId");
+    }
+    const diffs = await (0, schemaMigration_1.migrateSchema)({
+        options,
+        schema: serviceInfo.schema,
+        allowNonInteractiveMigration: true,
+        validateOnly: true,
+    });
+    if (diffs.length) {
+        logger_1.logger.info(`Schema sucessfully migrated! Run 'firebase deploy' to deploy your new schema to your Data Connect service.`);
+    }
+    else {
+        logger_1.logger.info("Schema was already up to date!");
+    }
+    return { projectId, serviceId, diffs };
+});

package/lib/commands/deploy.js

@@ -23,6 +23,7 @@ exports.VALID_DEPLOY_TARGETS = [
     "hosting",
     "remoteconfig",
     "extensions",
+    "dataconnect",
 ];
 exports.TARGET_PERMISSIONS = {
     database: ["firebasedatabase.instances.update"],
@@ -47,6 +48,29 @@ exports.TARGET_PERMISSIONS = {
         "firebaserules.releases.update",
     ],
     remoteconfig: ["cloudconfig.configs.get", "cloudconfig.configs.update"],
+    dataconnect: [
+        "cloudsql.databases.create",
+        "cloudsql.databases.update",
+        "cloudsql.instances.connect",
+        "cloudsql.instances.create",
+        "cloudsql.instances.get",
+        "cloudsql.instances.list",
+        "cloudsql.instances.update",
+        "cloudsql.users.create",
+        "firebasedataconnect.connectors.create",
+        "firebasedataconnect.connectors.delete",
+        "firebasedataconnect.connectors.list",
+        "firebasedataconnect.connectors.update",
+        "firebasedataconnect.operations.get",
+        "firebasedataconnect.services.create",
+        "firebasedataconnect.services.delete",
+        "firebasedataconnect.services.update",
+        "firebasedataconnect.services.list",
+        "firebasedataconnect.schemas.create",
+        "firebasedataconnect.schemas.delete",
+        "firebasedataconnect.schemas.list",
+        "firebasedataconnect.schemas.update",
+    ],
 };
 exports.command = new command_1.Command("deploy")
     .description("deploy code and assets to your Firebase project")
@@ -56,7 +80,9 @@ exports.command = new command_1.Command("deploy")
     .option("--only <targets>", 'only deploy to specified, comma-separated targets (e.g. "hosting,storage"). For functions, ' +
     'can specify filters with colons to scope function deploys to only those functions (e.g. "--only functions:func1,functions:func2"). ' +
     "When filtering based on export groups (the exported module object keys), use dots to specify group names " +
-    '(e.g. "--only functions:group1.subgroup1,functions:group2)"')
+    '(e.g. "--only functions:group1.subgroup1,functions:group2)"' +
+    "For data connect, can specify filters with colons to deploy only a service, connector, or schema" +
+    '(e.g. "--only dataconnect:serviceId,dataconnect:serviceId:connectorId,dataconnect:serviceId:schema"). ')
     .option("--except <targets>", 'deploy to all targets except specified (e.g. "database")')
     .before(requireConfig_1.requireConfig)
     .before((options) => {

package/lib/commands/index.js

@@ -200,6 +200,16 @@ function load(client) {
     client.setup.emulators.pubsub = loadCommand("setup-emulators-pubsub");
     client.setup.emulators.storage = loadCommand("setup-emulators-storage");
     client.setup.emulators.ui = loadCommand("setup-emulators-ui");
+    if (experiments.isEnabled("dataconnect")) {
+        client.dataconnect = {};
+        client.setup.emulators.dataconnect = loadCommand("setup-emulators-dataconnect");
+        client.dataconnect.list = loadCommand("dataconnect-list");
+        client.dataconnect.sql = {};
+        client.dataconnect.sql.diff = loadCommand("dataconnect-sql-diff");
+        client.dataconnect.sql.migrate = loadCommand("dataconnect-sql-migrate");
+        client.dataconnect.sdk = {};
+        client.dataconnect.sdk.generate = loadCommand("dataconnect-sdk-generate");
+    }
     client.target = loadCommand("target");
     client.target.apply = loadCommand("target-apply");
     client.target.clear = loadCommand("target-clear");

package/lib/commands/init.js

@@ -76,6 +76,13 @@ if ((0, experiments_1.isEnabled)("apphosting")) {
         checked: false,
     });
 }
+if ((0, experiments_1.isEnabled)("dataconnect")) {
+    choices.push({
+        value: "dataconnect",
+        name: "Data Connect: Set up a Firebase Data Connect service.",
+        checked: false,
+    });
+}
 const featureNames = choices.map((choice) => choice.value);
 const DESCRIPTION = `Interactively configure the current directory as a Firebase project or initialize new features in an already configured Firebase project directory.
 

package/lib/commands/setup-emulators-dataconnect.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const download_1 = require("../emulator/download");
+const types_1 = require("../emulator/types");
+const NAME = types_1.Emulators.DATACONNECT;
+exports.command = new command_1.Command(`setup:emulators:${NAME}`)
+    .description(`downloads the ${NAME} emulator`)
+    .action(() => {
+    return (0, download_1.downloadEmulator)(NAME);
+});

package/lib/config.js

@@ -226,4 +226,5 @@ Config.MATERIALIZE_TARGETS = [
     "hosting",
     "storage",
     "remoteconfig",
+    "dataconnect",
 ];

package/lib/dataconnect/build.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+const dataconnectEmulator_1 = require("../emulator/dataconnectEmulator");
+const error_1 = require("../error");
+const graphqlError_1 = require("./graphqlError");
+async function build(options, configDir) {
+    var _a, _b, _c;
+    const projectId = (_a = options.project) !== null && _a !== void 0 ? _a : "demo-test";
+    const args = {
+        projectId,
+        configDir,
+        auto_download: true,
+        rc: options.rc,
+    };
+    const dataconnectEmulator = new dataconnectEmulator_1.DataConnectEmulator(args);
+    const buildResult = await dataconnectEmulator.build();
+    if ((_b = buildResult === null || buildResult === void 0 ? void 0 : buildResult.errors) === null || _b === void 0 ? void 0 : _b.length) {
+        throw new error_1.FirebaseError(`There are errors in your schema and connector files:\n${buildResult.errors.map(graphqlError_1.prettify).join("\n")}`);
+    }
+    return (_c = buildResult === null || buildResult === void 0 ? void 0 : buildResult.metadata) !== null && _c !== void 0 ? _c : {};
+}
+exports.build = build;

package/lib/dataconnect/checkIam.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grantRolesToCloudSqlServiceAccount = void 0;
+const iam = require("../gcp/iam");
+const resourceManager_1 = require("../gcp/resourceManager");
+const cloudSqlAdmin = require("../gcp/cloudsql/cloudsqladmin");
+const error_1 = require("../error");
+async function grantRolesToCloudSqlServiceAccount(projectId, instanceId, roles) {
+    const instance = await cloudSqlAdmin.getInstance(projectId, instanceId);
+    const saEmail = instance.serviceAccountEmailAddress;
+    const policy = await (0, resourceManager_1.getIamPolicy)(projectId);
+    const requiredBindings = roles.map((r) => {
+        const binding = {
+            role: r,
+            members: [`serviceAccount:${saEmail}`],
+        };
+        return binding;
+    });
+    const updated = iam.mergeBindings(policy, requiredBindings);
+    if (updated) {
+        try {
+            await (0, resourceManager_1.setIamPolicy)(projectId, policy, "bindings");
+        }
+        catch (err) {
+            iam.printManualIamConfig(requiredBindings, projectId, "dataconnect");
+            throw new error_1.FirebaseError("Unable to make required IAM policy changes.");
+        }
+    }
+}
+exports.grantRolesToCloudSqlServiceAccount = grantRolesToCloudSqlServiceAccount;

package/lib/dataconnect/client.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertConnector = exports.listConnectors = exports.deleteConnector = exports.getConnector = exports.upsertSchema = exports.getSchema = exports.deleteService = exports.createService = exports.listServices = exports.listAllServices = exports.listLocations = void 0;
+const api_1 = require("../api");
+const apiv2_1 = require("../apiv2");
+const operationPoller = require("../operation-poller");
+const types = require("./types");
+const logger_1 = require("../logger");
+const DATACONNECT_API_VERSION = "v1alpha";
+const dataconnectClient = () => new apiv2_1.Client({
+    urlPrefix: (0, api_1.dataconnectOrigin)(),
+    apiVersion: DATACONNECT_API_VERSION,
+    auth: true,
+});
+async function listLocations(projectId) {
+    var _a, _b, _c;
+    const res = await dataconnectClient().get(`/projects/${projectId}/locations`);
+    return (_c = (_b = (_a = res.body) === null || _a === void 0 ? void 0 : _a.locations) === null || _b === void 0 ? void 0 : _b.map((l) => l.locationId)) !== null && _c !== void 0 ? _c : [];
+}
+exports.listLocations = listLocations;
+async function listAllServices(projectId) {
+    const locations = await listLocations(projectId);
+    let services = [];
+    for (const l of locations) {
+        try {
+            const locationServices = await listServices(projectId, l);
+            services = services.concat(locationServices);
+        }
+        catch (err) {
+            logger_1.logger.debug(`Unable to listServices in ${l}: ${err}`);
+        }
+    }
+    return services;
+}
+exports.listAllServices = listAllServices;
+async function listServices(projectId, locationId) {
+    var _a;
+    const res = await dataconnectClient().get(`/projects/${projectId}/locations/${locationId}/services`);
+    return (_a = res.body.services) !== null && _a !== void 0 ? _a : [];
+}
+exports.listServices = listServices;
+async function createService(projectId, locationId, serviceId) {
+    const op = await dataconnectClient().post(`/projects/${projectId}/locations/${locationId}/services`, {
+        name: `projects/${projectId}/locations/${locationId}/services/${serviceId}`,
+    }, {
+        queryParams: {
+            service_id: serviceId,
+        },
+    });
+    const pollRes = await operationPoller.pollOperation({
+        apiOrigin: (0, api_1.dataconnectOrigin)(),
+        apiVersion: DATACONNECT_API_VERSION,
+        operationResourceName: op.body.name,
+    });
+    return pollRes;
+}
+exports.createService = createService;
+async function deleteService(projectId, locationId, serviceId) {
+    const op = await dataconnectClient().delete(`projects/${projectId}/locations/${locationId}/services/${serviceId}?force=true`);
+    const pollRes = await operationPoller.pollOperation({
+        apiOrigin: (0, api_1.dataconnectOrigin)(),
+        apiVersion: DATACONNECT_API_VERSION,
+        operationResourceName: op.body.name,
+    });
+    return pollRes;
+}
+exports.deleteService = deleteService;
+async function getSchema(serviceName) {
+    const res = await dataconnectClient().get(`${serviceName}/schemas/${types.SCHEMA_ID}`);
+    return res.body;
+}
+exports.getSchema = getSchema;
+async function upsertSchema(schema, validateOnly = false) {
+    const op = await dataconnectClient().patch(`${schema.name}`, schema, {
+        queryParams: {
+            allowMissing: "true",
+            validateOnly: validateOnly ? "true" : "false",
+        },
+    });
+    if (validateOnly) {
+        return;
+    }
+    return operationPoller.pollOperation({
+        apiOrigin: (0, api_1.dataconnectOrigin)(),
+        apiVersion: DATACONNECT_API_VERSION,
+        operationResourceName: op.body.name,
+    });
+}
+exports.upsertSchema = upsertSchema;
+async function getConnector(name) {
+    const res = await dataconnectClient().get(name);
+    return res.body;
+}
+exports.getConnector = getConnector;
+async function deleteConnector(name) {
+    const res = await dataconnectClient().delete(name);
+    return res.body;
+}
+exports.deleteConnector = deleteConnector;
+async function listConnectors(serviceName) {
+    var _a;
+    const res = await dataconnectClient().get(`${serviceName}/connectors`);
+    return ((_a = res.body) === null || _a === void 0 ? void 0 : _a.connectors) || [];
+}
+exports.listConnectors = listConnectors;
+async function upsertConnector(connector) {
+    const op = await dataconnectClient().patch(`${connector.name}?allow_missing=true`, connector);
+    const pollRes = await operationPoller.pollOperation({
+        apiOrigin: (0, api_1.dataconnectOrigin)(),
+        apiVersion: DATACONNECT_API_VERSION,
+        operationResourceName: op.body.name,
+    });
+    return pollRes;
+}
+exports.upsertConnector = upsertConnector;

package/lib/dataconnect/dataplaneClient.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeGraphQL = void 0;
+const api_1 = require("../api");
+const apiv2_1 = require("../apiv2");
+const DATACONNECT_API_VERSION = "v1alpha";
+const dataconnectDataplaneClient = () => new apiv2_1.Client({
+    urlPrefix: (0, api_1.dataconnectOrigin)(),
+    apiVersion: DATACONNECT_API_VERSION,
+    auth: true,
+});
+async function executeGraphQL(servicePath, body) {
+    const res = await dataconnectDataplaneClient().post(`${servicePath}:executeGraphql`, body, { resolveOnHTTPError: true });
+    return res;
+}
+exports.executeGraphQL = executeGraphQL;

package/lib/dataconnect/ensureApis.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureApis = void 0;
+const api = require("../api");
+const ensureApiEnabled_1 = require("../ensureApiEnabled");
+async function ensureApis(projectId) {
+    const prefix = "dataconnect";
+    await (0, ensureApiEnabled_1.ensure)(projectId, api.dataconnectOrigin(), prefix);
+    await (0, ensureApiEnabled_1.ensure)(projectId, api.cloudSQLAdminOrigin(), prefix);
+    await (0, ensureApiEnabled_1.ensure)(projectId, api.computeOrigin(), prefix);
+}
+exports.ensureApis = ensureApis;

package/lib/dataconnect/fileUtils.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickService = exports.readGQLFiles = exports.readConnectorYaml = exports.readDataConnectYaml = exports.readFirebaseJson = void 0;
+const fs = require("fs-extra");
+const path = require("path");
+const error_1 = require("../error");
+const utils_1 = require("../utils");
+const load_1 = require("./load");
+function readFirebaseJson(config) {
+    if (!config.has("dataconnect")) {
+        return [];
+    }
+    const validator = (cfg) => {
+        if (!cfg["source"] && !cfg["location"]) {
+            throw new error_1.FirebaseError("Invalid firebase.json: DataConnect requires `source` and `location`");
+        }
+        return {
+            source: cfg["source"],
+            location: cfg["location"],
+        };
+    };
+    const configs = config.get("dataconnect");
+    if (typeof configs === "object" && !Array.isArray(configs)) {
+        return [validator(configs)];
+    }
+    else if (Array.isArray(configs)) {
+        return configs.map(validator);
+    }
+    else {
+        throw new error_1.FirebaseError("Invalid firebase.json: dataconnect should be of the form { source: string, location: string }");
+    }
+}
+exports.readFirebaseJson = readFirebaseJson;
+async function readDataConnectYaml(sourceDirectory) {
+    const file = await (0, utils_1.readFileFromDirectory)(sourceDirectory, "dataconnect.yaml");
+    const dataconnectYaml = await (0, utils_1.wrappedSafeLoad)(file.source);
+    return validateDataConnectYaml(dataconnectYaml);
+}
+exports.readDataConnectYaml = readDataConnectYaml;
+function validateDataConnectYaml(unvalidated) {
+    return unvalidated;
+}
+async function readConnectorYaml(sourceDirectory) {
+    const file = await (0, utils_1.readFileFromDirectory)(sourceDirectory, "connector.yaml");
+    const connectorYaml = await (0, utils_1.wrappedSafeLoad)(file.source);
+    return validateConnectorYaml(connectorYaml);
+}
+exports.readConnectorYaml = readConnectorYaml;
+function validateConnectorYaml(unvalidated) {
+    return unvalidated;
+}
+async function readGQLFiles(sourceDir) {
+    const files = await fs.readdir(sourceDir);
+    return files.filter((f) => f.endsWith(".gql")).map((f) => toFile(path.join(sourceDir, f)));
+}
+exports.readGQLFiles = readGQLFiles;
+function toFile(path) {
+    if (!fs.existsSync(path)) {
+        throw new error_1.FirebaseError(`file ${path} not found`);
+    }
+    const file = fs.readFileSync(path).toString();
+    return {
+        path: path,
+        content: file,
+    };
+}
+async function pickService(projectId, config, serviceId) {
+    const serviceCfgs = readFirebaseJson(config);
+    let serviceInfo;
+    if (serviceCfgs.length === 0) {
+        throw new error_1.FirebaseError("No Data Connect services found in firebase.json.");
+    }
+    else if (serviceCfgs.length === 1) {
+        serviceInfo = await (0, load_1.load)(projectId, serviceCfgs[0].location, serviceCfgs[0].source);
+    }
+    else {
+        if (!serviceId) {
+            throw new error_1.FirebaseError("Multiple Data Connect services found in firebase.json. Please specify a service ID to use.");
+        }
+        const infos = await Promise.all(serviceCfgs.map((c) => (0, load_1.load)(projectId, c.location, c.source)));
+        const maybe = infos.find((i) => i.dataConnectYaml.serviceId === serviceId);
+        if (!maybe) {
+            throw new error_1.FirebaseError(`No service named ${serviceId} declared in firebase.json.`);
+        }
+        serviceInfo = maybe;
+    }
+    return serviceInfo;
+}
+exports.pickService = pickService;

package/lib/dataconnect/filters.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResourceFilters = void 0;
+const error_1 = require("../error");
+function getResourceFilters(options) {
+    if (!options.only) {
+        return undefined;
+    }
+    const selectors = options.only.split(",");
+    const filters = [];
+    for (let selector of selectors) {
+        if (selector.startsWith("dataconnect:")) {
+            selector = selector.replace("dataconnect:", "");
+            if (selector.length > 0) {
+                filters.push(parseSelector(selector));
+            }
+        }
+    }
+    if (filters.length === 0) {
+        return undefined;
+    }
+    return filters;
+}
+exports.getResourceFilters = getResourceFilters;
+function parseSelector(selector) {
+    const parts = selector.split(":");
+    const filter = {
+        serviceId: parts[0],
+    };
+    if (parts.length === 2) {
+        if (parts[1] === "schema") {
+            filter.schemaOnly = true;
+        }
+        else {
+            filter.connectorId = parts[1];
+        }
+    }
+    else if (parts.length === 1) {
+        filter.fullService = true;
+    }
+    else {
+        throw new error_1.FirebaseError(`Invalid '--only' filter dataconnect:${selector}`);
+    }
+    return filter;
+}

package/lib/dataconnect/freeTrial.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printFreeTrialUnavailable = exports.checkForFreeTrialInstance = exports.freeTrialTermsLink = void 0;
+const cloudsqladmin_1 = require("../gcp/cloudsql/cloudsqladmin");
+const utils = require("../utils");
+function freeTrialTermsLink() {
+    return "";
+}
+exports.freeTrialTermsLink = freeTrialTermsLink;
+async function checkForFreeTrialInstance(projectId) {
+    var _a;
+    const instances = await (0, cloudsqladmin_1.listInstances)(projectId);
+    return (_a = instances.find((i) => { var _a; return ((_a = i.settings.userLabels) === null || _a === void 0 ? void 0 : _a["firebase-data-connect"]) === "ft"; })) === null || _a === void 0 ? void 0 : _a.name;
+}
+exports.checkForFreeTrialInstance = checkForFreeTrialInstance;
+function printFreeTrialUnavailable(projectId, instanceId) {
+    const message = `Project '${projectId}' already has a CloudSQL instance '${instanceId}' on the Firebase Data Connect free trial. ` +
+        "The free trial only includes one CloudSQL instance. " +
+        `Consider using a separate database on ${instanceId}, or creating a new CloudSQL instance at ` +
+        "https://console.cloud.google.com/sql/instances";
+    utils.logLabeledError("dataconnect", message);
+}
+exports.printFreeTrialUnavailable = printFreeTrialUnavailable;

package/lib/dataconnect/graphqlError.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettify = void 0;
+function prettify(err) {
+    var _a;
+    const message = err.message;
+    let header = (_a = err.extensions.file) !== null && _a !== void 0 ? _a : "";
+    for (const loc of err.locations) {
+        header += `(${loc.line}, ${loc.column})`;
+    }
+    return header.length ? `${header}: ${message}` : message;
+}
+exports.prettify = prettify;

package/lib/dataconnect/load.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.load = void 0;
+const path = require("path");
+const fileUtils = require("./fileUtils");
+const types_1 = require("./types");
+async function load(projectId, locationId, sourceDirectory) {
+    const dataConnectYaml = await fileUtils.readDataConnectYaml(sourceDirectory);
+    const serviceName = `projects/${projectId}/locations/${locationId}/services/${dataConnectYaml.serviceId}`;
+    const schemaDir = path.join(sourceDirectory, dataConnectYaml.schema.source);
+    const schemaGQLs = await fileUtils.readGQLFiles(schemaDir);
+    const connectorInfo = await Promise.all(dataConnectYaml.connectorDirs.map(async (dir) => {
+        const connectorDir = path.join(sourceDirectory, dir);
+        const connectorYaml = await fileUtils.readConnectorYaml(connectorDir);
+        const connectorGqls = await fileUtils.readGQLFiles(connectorDir);
+        return {
+            connectorYaml,
+            connector: {
+                name: `${serviceName}/connectors/${connectorYaml.connectorId}`,
+                source: {
+                    files: connectorGqls,
+                },
+            },
+        };
+    }));
+    return {
+        serviceName,
+        sourceDirectory,
+        schema: {
+            name: `${serviceName}/schemas/${types_1.SCHEMA_ID}`,
+            primaryDatasource: (0, types_1.toDatasource)(projectId, locationId, dataConnectYaml.schema.datasource),
+            source: {
+                files: schemaGQLs,
+            },
+        },
+        dataConnectYaml,
+        connectorInfo,
+    };
+}
+exports.load = load;