import { UrlLoader } from '@graphql-tools/url-loader';
import { invert, cloneDeep, isEmpty, isArray, map, isObject, isDate, isFunction, extend, mapValues, set } from 'lodash';
import { URL as URL$1 } from 'url';
import 'isomorphic-fetch';
import { sign, decode } from 'jsonwebtoken';
import { GraphQLClient } from 'graphql-request';
import chalk from 'chalk';
import HttpsProxyAgent from 'https-proxy-agent';
import HttpProxyAgent from 'http-proxy-agent';
import Ajv from 'ajv';
import { safeLoad, safeDump } from 'js-yaml';
import { accessSync, readFileSync, writeFileSync, mkdirSync, promises } from 'fs';
import replaceall from 'replaceall';
import { resolve, all, reduce } from 'bluebird';
import stringify from 'json-stable-stringify';
import { config } from 'dotenv';
import { dirname, resolve as resolve$1, join } from 'path';
import { safeLoad as safeLoad$1 } from 'yaml-ast-parser';
import { homedir } from 'os';
import { cwd } from 'process';

const cloudApiEndpoint = process.env.CLOUD_API_ENDPOINT || 'https://api.cloud.prisma.sh';
const clusterEndpointMap = {
    'prisma-eu1': 'https://eu1.prisma.sh',
    'prisma-us1': 'https://us1.prisma.sh',
};
const clusterEndpointMapReverse = invert(clusterEndpointMap);

function getClusterName(origin) {
    if (clusterEndpointMapReverse[origin]) {
        return clusterEndpointMapReverse[origin];
    }
    if (origin.endsWith('prisma.sh')) {
        return origin.split('_')[0].replace(/https?:\/\//, '');
    }
    if (isLocal(origin)) {
        return 'local';
    }
    return 'default';
}
const getWorkspaceFromPrivateOrigin = (origin) => {
    const split = origin.split('_');
    if (split.length > 1) {
        return split[1].split('.')[0];
    }
    return null;
};
const isLocal = (origin) => origin.includes('localhost') || origin.includes('127.0.0.1');
function parseEndpoint(endpoint) {
    /*
      Terminology:
        local - hosted locally using docker and accessed using localhost or prisma or local web proxy like domain.dev
        shared - demo server
        isPrivate - private hosted by Prisma or private and self-hosted, important that in our terminology a local server is not private
    */
    const url = new URL$1(endpoint);
    const splittedPath = url.pathname.split('/');
    // assuming, that the pathname always starts with a leading /, we always can ignore the first element of the split array
    const service = splittedPath.length > 3 ? splittedPath[2] : splittedPath[1] || 'default';
    const stage = splittedPath.length > 3 ? splittedPath[3] : splittedPath[2] || 'default';
    // This logic might break for self-hosted servers incorrectly yielding a "workspace" simply if the UX has
    // enough "/"es like if https://custom.dev/not-a-workspace/ is the base Prisma URL then for default/default service/stage
    // pair. This function would incorrectly return not-a-workspace as a workspace.
    let workspaceSlug = splittedPath.length > 3 ? splittedPath[1] : null;
    const shared = ['eu1.prisma.sh', 'us1.prisma.sh'].includes(url.host);
    // When using localAliases, do an exact match because of 'prisma' option which is added for local docker networking access
    const localAliases = ['localhost', '127.0.0.1', 'prisma'];
    const isPrivate = !shared && !localAliases.includes(url.hostname);
    const local = !shared && !isPrivate && !workspaceSlug;
    if (isPrivate && !workspaceSlug) {
        workspaceSlug = getWorkspaceFromPrivateOrigin(url.origin);
    }
    return {
        clusterBaseUrl: url.origin,
        service,
        stage,
        local,
        isPrivate,
        shared,
        workspaceSlug,
        clusterName: getClusterName(url.origin),
    };
}

// code from https://raw.githubusercontent.com/request/request/5ba8eb44da7cd639ca21070ea9be20d611b85f66/lib/getProxyFromURI.js
function formatHostname(hostname) {
    // canonicalize the hostname, so that 'oogle.com' won't match 'google.com'
    return hostname.replace(/^\.*/, '.').toLowerCase();
}
function parseNoProxyZone(zone) {
    zone = zone.trim().toLowerCase();
    const zoneParts = zone.split(':', 2);
    const zoneHost = formatHostname(zoneParts[0]);
    const zonePort = zoneParts[1];
    const hasPort = zone.indexOf(':') > -1;
    return { hostname: zoneHost, port: zonePort, hasPort: hasPort };
}
function uriInNoProxy(uri, noProxy) {
    const port = uri.port || (uri.protocol === 'https:' ? '443' : '80');
    const hostname = formatHostname(uri.hostname);
    const noProxyList = noProxy.split(',');
    // iterate through the noProxyList until it finds a match.
    return noProxyList.map(parseNoProxyZone).some(function (noProxyZone) {
        const isMatchedAt = hostname.indexOf(noProxyZone.hostname);
        const hostnameMatched = isMatchedAt > -1 && isMatchedAt === hostname.length - noProxyZone.hostname.length;
        if (noProxyZone.hasPort) {
            return port === noProxyZone.port && hostnameMatched;
        }
        return hostnameMatched;
    });
}
function getProxyFromURI(uri) {
    // Decide the proper request proxy to use based on the request URI object and the
    // environmental variables (NO_PROXY, HTTP_PROXY, etc.)
    // respect NO_PROXY environment variables (see: http://lynx.isc.org/current/breakout/lynx_help/keystrokes/environments.html)
    const noProxy = process.env.NO_PROXY || process.env.no_proxy || '';
    // if the noProxy is a wildcard then return null
    if (noProxy === '*') {
        return null;
    }
    // if the noProxy is not empty and the uri is found return null
    if (noProxy !== '' && uriInNoProxy(uri, noProxy)) {
        return null;
    }
    // Check for HTTP or HTTPS Proxy in environment Else default to null
    if (uri.protocol === 'http:') {
        return process.env.HTTP_PROXY || process.env.http_proxy || null;
    }
    if (uri.protocol === 'https:') {
        return (process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy || null);
    }
    // if none of that works, return null
    // (What uri protocol are you using then?)
    return null;
}
function getProxyAgent(url) {
    const uri = new URL(url);
    const proxy = getProxyFromURI(uri);
    if (!proxy) {
        return undefined;
    }
    const proxyUri = new URL(proxy);
    if (proxyUri.protocol === 'http:') {
        // eslint-disable-next-line
        // @ts-ignore
        return new HttpProxyAgent(proxy);
    }
    if (proxyUri.protocol === 'https:') {
        // eslint-disable-next-line
        // @ts-ignore
        return new HttpsProxyAgent(proxy);
    }
    return undefined;
}

const debug = require('debug')('environment');
class Cluster {
    constructor(out, name, baseUrl, clusterSecret, local = true, shared = false, isPrivate = false, workspaceSlug) {
        this.out = out;
        this.name = name;
        // All `baseUrl` extension points in this class
        // adds a trailing slash. Here we remove it from
        // the passed `baseUrl` in order to avoid double
        // slashes.
        this.baseUrl = baseUrl.replace(/\/$/, '');
        this.clusterSecret = clusterSecret;
        this.local = local;
        this.shared = shared;
        this.isPrivate = isPrivate;
        this.workspaceSlug = workspaceSlug;
        this.hasOldDeployEndpoint = false;
    }
    async getToken(serviceName, workspaceSlug, stageName) {
        // public clusters just take the token
        const needsAuth = await this.needsAuth();
        debug({ needsAuth });
        if (!needsAuth) {
            return null;
        }
        if (this.name === 'shared-public-demo') {
            return '';
        }
        if (this.isPrivate && process.env.PRISMA_MANAGEMENT_API_SECRET) {
            return this.getLocalToken();
        }
        if (this.shared || (this.isPrivate && !process.env.PRISMA_MANAGEMENT_API_SECRET)) {
            return this.generateClusterToken(serviceName, workspaceSlug, stageName);
        }
        else {
            return this.getLocalToken();
        }
    }
    getLocalToken() {
        if (!this.clusterSecret && !process.env.PRISMA_MANAGEMENT_API_SECRET) {
            return null;
        }
        if (!this.cachedToken) {
            const grants = [{ target: `*/*`, action: '*' }];
            const secret = process.env.PRISMA_MANAGEMENT_API_SECRET || this.clusterSecret;
            try {
                const algorithm = process.env.PRISMA_MANAGEMENT_API_SECRET ? 'HS256' : 'RS256';
                this.cachedToken = sign({ grants }, secret, {
                    expiresIn: '5y',
                    algorithm,
                });
            }
            catch (e) {
                throw new Error(`Could not generate token for cluster ${chalk.bold(this.getDeployEndpoint())}. Did you provide the env var PRISMA_MANAGEMENT_API_SECRET?
Original error: ${e.message}`);
            }
        }
        return this.cachedToken;
    }
    get cloudClient() {
        return new GraphQLClient(cloudApiEndpoint, {
            headers: {
                Authorization: `Bearer ${this.clusterSecret}`,
            },
            agent: getProxyAgent(cloudApiEndpoint),
        });
    }
    async generateClusterToken(serviceName, workspaceSlug = this.workspaceSlug || '*', stageName) {
        const query = `
      mutation ($input: GenerateClusterTokenRequest!) {
        generateClusterToken(input: $input) {
          clusterToken
        }
      }
    `;
        const { generateClusterToken: { clusterToken }, } = await this.cloudClient.request(query, {
            input: {
                workspaceSlug,
                clusterName: this.name,
                serviceName,
                stageName,
            },
        });
        return clusterToken;
    }
    async addServiceToCloudDBIfMissing(serviceName, workspaceSlug = this.workspaceSlug, stageName) {
        const query = `
      mutation ($input: GenerateClusterTokenRequest!) {
        addServiceToCloudDBIfMissing(input: $input)
      }
    `;
        const serviceCreated = await this.cloudClient.request(query, {
            input: {
                workspaceSlug,
                clusterName: this.name,
                serviceName,
                stageName,
            },
        });
        return serviceCreated.addServiceToCloudDBIfMissing;
    }
    getApiEndpoint(service, stage, workspaceSlug) {
        if (!this.shared && service === 'default' && stage === 'default') {
            return this.baseUrl;
        }
        if (!this.shared && stage === 'default') {
            return `${this.baseUrl}/${service}`;
        }
        if (this.isPrivate || this.local) {
            return `${this.baseUrl}/${service}/${stage}`;
        }
        const workspaceString = workspaceSlug ? `${workspaceSlug}/` : '';
        return `${this.baseUrl}/${workspaceString}${service}/${stage}`;
    }
    getWSEndpoint(service, stage, workspaceSlug) {
        return this.getApiEndpoint(service, stage, workspaceSlug).replace(/^http/, 'ws');
    }
    getImportEndpoint(service, stage, workspaceSlug) {
        return this.getApiEndpoint(service, stage, workspaceSlug) + `/import`;
    }
    getExportEndpoint(service, stage, workspaceSlug) {
        return this.getApiEndpoint(service, stage, workspaceSlug) + `/export`;
    }
    getDeployEndpoint() {
        return `${this.baseUrl}/${this.hasOldDeployEndpoint ? 'cluster' : 'management'}`;
    }
    async isOnline() {
        const version = await this.getVersion();
        return typeof version === 'string';
    }
    async getVersion() {
        // first try new api
        try {
            const result = await this.request(`{
        serverInfo {
          version
        }
      }`);
            const res = await result.json();
            const { data, errors } = res;
            if (errors && errors[0].code === 3016 && errors[0].message.includes('management@default')) {
                this.hasOldDeployEndpoint = true;
                return await this.getVersion();
            }
            if (data && data.serverInfo) {
                return data.serverInfo.version;
            }
        }
        catch (e) {
            debug(e);
        }
        // if that doesn't work, try the old one
        try {
            const result = await this.request(`{
        serverInfo {
          version
        }
      }`);
            const res = await result.json();
            const { data } = res;
            return data.serverInfo.version;
        }
        catch (e) {
            debug(e);
        }
        return null;
    }
    request(query, variables) {
        return fetch(this.getDeployEndpoint(), {
            method: 'post',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify({
                query,
                variables,
            }),
            agent: getProxyAgent(this.getDeployEndpoint()),
        });
    }
    async needsAuth() {
        try {
            const result = await this.request(`{
        listProjects {
          name
        }
      }`);
            const data = await result.json();
            if (data.errors && data.errors.length > 0) {
                return true;
            }
            return false;
        }
        catch (e) {
            debug('Assuming that the server needs authentication');
            debug(e.toString());
            return true;
        }
    }
    toJSON() {
        return {
            name: this.name,
            baseUrl: this.baseUrl,
            local: this.local,
            clusterSecret: this.clusterSecret,
            shared: this.shared,
            isPrivate: this.isPrivate,
            workspaceSlug: this.workspaceSlug,
        };
    }
}

const schema = JSON.parse(`{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "JSON schema for Prisma prisma.yml files",
  "definitions": {
    "subscription": {
      "description": "A piece of code that you should run.",
      "type": "object",
      "properties": {
        "query": {
          "type": "string"
        },
        "webhook": {
          "oneOf": [
            {
              "type": "string"
            },
            {
              "type": "object",
              "properties": {
                "url": {
                  "type": "string"
                },
                "headers": {
                  "type": "object"
                }
              },
              "required": ["url"]
            }
          ]
        }
      },
      "required": ["query", "webhook"]
    }
  },
  "properties": {
    "datamodel": {
      "description": "Type definitions for database models, relations, enums and other types",
      "type": ["string", "array"],
      "items": {
        "type": ["string", "array"]
      }
    },
    "secret": {
      "description": "Secret for securing the API Endpoint",
      "type": "string",
      "items": {
        "type": "string"
      }
    },
    "disableAuth": {
      "description": "Disable authentication for the endpoint",
      "type": "boolean",
      "items": {
        "type": "boolean"
      }
    },
    "generate": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "generator": {
            "type": "string"
          },
          "output": {
            "type": "string"
          }
        }
      }
    },
    "seed": {
      "description": "Database seed",
      "type": "object",
      "properties": {
        "import": {
          "type": "string"
        },
        "run": {
          "type": "string"
        }
      }
    },
    "subscriptions": {
      "description": "All server-side subscriptions",
      "type": "object",
      "additionalProperties": {
        "$ref": "#/definitions/subscription"
      }
    },
    "custom": {
      "description": "Custom field to use in variable interpolations with \${self:custom.field}",
      "type": "object"
    },
    "hooks": {
      "description": "Command hooks. Current available hooks are: post-deploy.",
      "type": "object"
    },
    "endpoint": {
      "description": "Endpoint the service will be reachable at. This also determines the cluster the service will deployed to.",
      "type": "string",
      "items": {
        "type": "string"
      }
    },
    "databaseType": {
      "type": "string",
      "oneOf": [{ "enum": ["relational", "document"] }]
    }
  },
  "additionalProperties": false
}`);

class Output {
    log(...args) {
        console.log(args);
    }
    warn(...args) {
        console.warn(args);
    }
    getErrorPrefix(fileName, type = 'error') {
        return `[${type.toUpperCase()}] in ${fileName}: `;
    }
}

class Variables {
    constructor(fileName, options = {}, out = new Output(), envVars) {
        this.overwriteSyntax = /,/g;
        this.envRefSyntax = /^env:/g;
        this.selfRefSyntax = /^self:/g;
        this.stringRefSyntax = /('.*')|(".*")/g;
        this.optRefSyntax = /^opt:/g;
        // eslint-disable-next-line
        this.variableSyntax = new RegExp(
        // eslint-disable-next-line
        '\\${([ ~:a-zA-Z0-9._\'",\\-\\/\\(\\)]+?)}', 'g');
        this.out = out;
        this.fileName = fileName;
        this.options = options;
        this.envVars = envVars || process.env;
    }
    populateJson(json) {
        this.json = json;
        return this.populateObject(this.json).then(() => {
            return resolve(this.json);
        });
    }
    populateObject(objectToPopulate) {
        const populateAll = [];
        const deepMapValues = (object, callback, propertyPath) => {
            const deepMapValuesIteratee = (value, key) => deepMapValues(value, callback, propertyPath ? propertyPath.concat(key) : [key]);
            if (isArray(object)) {
                return map(object, deepMapValuesIteratee);
            }
            else if (isObject(object) && !isDate(object) && !isFunction(object)) {
                return extend({}, object, mapValues(object, deepMapValuesIteratee));
            }
            return callback(object, propertyPath);
        };
        deepMapValues(objectToPopulate, (property, propertyPath) => {
            if (typeof property === 'string') {
                const populateSingleProperty = this.populateProperty(property, true)
                    .then((newProperty) => set(objectToPopulate, propertyPath, newProperty))
                    .return();
                populateAll.push(populateSingleProperty);
            }
        });
        return all(populateAll).then(() => objectToPopulate);
    }
    populateProperty(propertyParam, populateInPlace) {
        let property = populateInPlace ? propertyParam : cloneDeep(propertyParam);
        const allValuesToPopulate = [];
        let warned = false;
        if (typeof property === 'string' && property.match(this.variableSyntax)) {
            property.match(this.variableSyntax).forEach(matchedString => {
                const variableString = matchedString
                    .replace(this.variableSyntax, (_, varName) => varName.trim())
                    .replace(/\s/g, '');
                let singleValueToPopulate = null;
                if (variableString.match(this.overwriteSyntax)) {
                    singleValueToPopulate = this.overwrite(variableString);
                }
                else {
                    singleValueToPopulate = this.getValueFromSource(variableString).then((valueToPopulate) => {
                        if (typeof valueToPopulate === 'object') {
                            return this.populateObject(valueToPopulate);
                        }
                        return valueToPopulate;
                    });
                }
                singleValueToPopulate = singleValueToPopulate.then(valueToPopulate => {
                    if (this.warnIfNotFound(variableString, valueToPopulate)) {
                        warned = true;
                    }
                    return this.populateVariable(property, matchedString, valueToPopulate).then((newProperty) => {
                        property = newProperty;
                        return resolve(property);
                    });
                });
                allValuesToPopulate.push(singleValueToPopulate);
            });
            return all(allValuesToPopulate).then(() => {
                if (property !== this.json && !warned) {
                    return this.populateProperty(property);
                }
                return resolve(property);
            });
        }
        return resolve(property);
    }
    populateVariable(propertyParam, matchedString, valueToPopulate) {
        let property = propertyParam;
        if (typeof valueToPopulate === 'string') {
            property = replaceall(matchedString, valueToPopulate, property);
        }
        else {
            if (property !== matchedString) {
                if (typeof valueToPopulate === 'number') {
                    property = replaceall(matchedString, String(valueToPopulate), property);
                }
                else {
                    const errorMessage = [
                        'Trying to populate non string value into',
                        ` a string for variable ${matchedString}.`,
                        ' Please make sure the value of the property is a string.',
                    ].join('');
                    this.out.warn(this.out.getErrorPrefix(this.fileName, 'warning') + errorMessage);
                }
                return resolve(property);
            }
            property = valueToPopulate;
        }
        return resolve(property);
    }
    overwrite(variableStringsString) {
        let finalValue;
        const variableStringsArray = variableStringsString.split(',');
        const allValuesFromSource = variableStringsArray.map((variableString) => this.getValueFromSource(variableString));
        return all(allValuesFromSource).then((valuesFromSources) => {
            valuesFromSources.find((valueFromSource) => {
                finalValue = valueFromSource;
                return (finalValue !== null &&
                    typeof finalValue !== 'undefined' &&
                    !(typeof finalValue === 'object' && isEmpty(finalValue)));
            });
            return resolve(finalValue);
        });
    }
    getValueFromSource(variableString) {
        if (variableString.match(this.envRefSyntax)) {
            return this.getValueFromEnv(variableString);
        }
        else if (variableString.match(this.optRefSyntax)) {
            return this.getValueFromOptions(variableString);
        }
        else if (variableString.match(this.selfRefSyntax)) {
            return this.getValueFromSelf(variableString);
        }
        else if (variableString.match(this.stringRefSyntax)) {
            return this.getValueFromString(variableString);
        }
        const errorMessage = [
            `Invalid variable reference syntax for variable ${variableString}.`,
            ' You can only reference env vars, options, & files.',
            ' You can check our docs for more info.',
        ].join('');
        this.out.warn(this.out.getErrorPrefix(this.fileName, 'warning') + errorMessage);
    }
    getValueFromEnv(variableString) {
        const requestedEnvVar = variableString.split(':')[1];
        const valueToPopulate = requestedEnvVar !== '' || '' in this.envVars ? this.envVars[requestedEnvVar] : this.envVars;
        return resolve(valueToPopulate);
    }
    getValueFromString(variableString) {
        const valueToPopulate = variableString.replace(/^['"]|['"]$/g, '');
        return resolve(valueToPopulate);
    }
    getValueFromOptions(variableString) {
        const requestedOption = variableString.split(':')[1];
        const valueToPopulate = requestedOption !== '' || '' in this.options ? this.options[requestedOption] : this.options;
        return resolve(valueToPopulate);
    }
    getValueFromSelf(variableString) {
        const valueToPopulate = this.json;
        const deepProperties = variableString.split(':')[1].split('.');
        return this.getDeepValue(deepProperties, valueToPopulate);
    }
    getDeepValue(deepProperties, valueToPopulate) {
        return reduce(deepProperties, (computedValueToPopulateParam, subProperty) => {
            let computedValueToPopulate = computedValueToPopulateParam;
            if (typeof computedValueToPopulate === 'undefined') {
                computedValueToPopulate = {};
            }
            else if (subProperty !== '' || '' in computedValueToPopulate) {
                computedValueToPopulate = computedValueToPopulate[subProperty];
            }
            if (typeof computedValueToPopulate === 'string' && computedValueToPopulate.match(this.variableSyntax)) {
                return this.populateProperty(computedValueToPopulate);
            }
            return resolve(computedValueToPopulate);
        }, valueToPopulate);
    }
    warnIfNotFound(variableString, valueToPopulate) {
        if (valueToPopulate === null ||
            typeof valueToPopulate === 'undefined' ||
            (typeof valueToPopulate === 'object' && isEmpty(valueToPopulate))) {
            let varType;
            if (variableString.match(this.envRefSyntax)) {
                varType = 'environment variable';
            }
            else if (variableString.match(this.optRefSyntax)) {
                varType = 'option';
            }
            else if (variableString.match(this.selfRefSyntax)) {
                varType = 'self reference';
            }
            this.out.warn(this.out.getErrorPrefix(this.fileName, 'warning') +
                `A valid ${varType} to satisfy the declaration '${variableString}' could not be found.`);
            return true;
        }
        return false;
    }
}

const debug$1 = require('debug')('yaml');
const ajv = new Ajv();
const validate = ajv.compile(schema);
// this is used by the playground, which accepts additional properties
const validateGraceful = ajv.compile({ ...schema, additionalProperties: true });
async function readDefinition(filePath, args, out = new Output(), envVars, graceful) {
    try {
        accessSync(filePath);
    }
    catch (_a) {
        throw new Error(`${filePath} could not be found.`);
    }
    const file = readFileSync(filePath, 'utf-8');
    const json = safeLoad(file);
    // we need this copy because populateJson runs inplace
    const jsonCopy = { ...json };
    const vars = new Variables(filePath, args, out, envVars);
    const populatedJson = await vars.populateJson(json);
    if (populatedJson.custom) {
        delete populatedJson.custom;
    }
    const valid = graceful ? validateGraceful(populatedJson) : validate(populatedJson);
    // TODO activate as soon as the backend sends valid yaml
    if (!valid) {
        const errorMessage = `Invalid prisma.yml file` + '\n' + printErrors(graceful ? validateGraceful.errors : validate.errors);
        throw new Error(errorMessage);
    }
    return {
        definition: populatedJson,
        rawJson: jsonCopy,
    };
}
function printErrors(errors, name = 'prisma.yml') {
    return errors
        .map((e) => {
        const paramsKey = stringify(e.params);
        if (betterMessagesByParams[paramsKey]) {
            return betterMessagesByParams[paramsKey];
        }
        const params = Object.keys(e.params)
            .map(key => `${key}: ${e.params[key]}`)
            .join(', ');
        debug$1(stringify(e.params));
        return `${name}${e.dataPath} ${e.message}. ${params}`;
    })
        .join('\n');
}
const betterMessagesByParams = {
    // this is not up-to-date, stages are in again!
    // https://github.com/prisma/framework/issues/1461
    '{"additionalProperty":"stages"}': 'prisma.yml should NOT have a "stages" property anymore. Stages are now just provided as CLI args.\nRead more here: https://goo.gl/SUD5i5',
    '{"additionalProperty":"types"}': 'prisma.yml should NOT have a "types" property anymore. It has been renamed to "datamodel"',
};

/**
 * Comments out the current entry of a specific key in a yaml document and creates a new value next to it
 * @param key key in yaml document to comment out
 * @param newValue new value to add in the document
 */
function replaceYamlValue(input, key, newValue) {
    const ast = safeLoad$1(input);
    const position = getPosition(ast, key);
    const newEntry = `${key}: ${newValue}\n`;
    if (!position) {
        return input + '\n' + newEntry;
    }
    return (input.slice(0, position.start) +
        '#' +
        input.slice(position.start, position.end) +
        newEntry +
        input.slice(position.end));
}
function getPosition(ast, key) {
    const mapping = ast.mappings.find((m) => m.key.value === key);
    if (!mapping) {
        return undefined;
    }
    return {
        start: mapping.startPosition,
        end: mapping.endPosition + 1,
    };
}

class PrismaDefinitionClass {
    constructor(env, definitionPath, envVars = process.env, out) {
        this.secrets = null;
        this.definitionPath = definitionPath;
        if (definitionPath) {
            this.definitionDir = dirname(definitionPath);
        }
        this.env = env;
        this.out = out;
        this.envVars = envVars;
    }
    async load(args, envPath, graceful) {
        if (args.project) {
            const flagPath = resolve$1(args.project);
            try {
                accessSync(flagPath);
            }
            catch (_a) {
                throw new Error(`Prisma definition path specified by --project '${flagPath}' does not exist`);
            }
            this.definitionPath = flagPath;
            this.definitionDir = dirname(flagPath);
            await this.loadDefinition(args, graceful);
            this.validate();
            return;
        }
        if (envPath) {
            try {
                accessSync(envPath);
            }
            catch (_b) {
                envPath = join(process.cwd(), envPath);
            }
            try {
                accessSync(envPath);
            }
            catch (_c) {
                throw new Error(`--env-file path '${envPath}' does not exist`);
            }
        }
        config({ path: envPath });
        if (this.definitionPath) {
            await this.loadDefinition(args, graceful);
            this.validate();
        }
        else {
            throw new Error(`Couldn’t find \`prisma.yml\` file. Are you in the right directory?`);
        }
    }
    async loadDefinition(args, graceful) {
        const { definition, rawJson } = await readDefinition(this.definitionPath, args, this.out, this.envVars, graceful);
        this.rawEndpoint = rawJson.endpoint;
        this.definition = definition;
        this.rawJson = rawJson;
        this.definitionString = readFileSync(this.definitionPath, 'utf-8');
        this.typesString = this.getTypesString(this.definition);
        const secrets = this.definition.secret;
        this.secrets = secrets ? secrets.replace(/\s/g, '').split(',') : null;
    }
    get endpoint() {
        return (this.definition && this.definition.endpoint) || process.env.PRISMA_MANAGEMENT_API_ENDPOINT;
    }
    get clusterBaseUrl() {
        if (!this.definition || !this.endpoint) {
            return undefined;
        }
        const { clusterBaseUrl } = parseEndpoint(this.endpoint);
        return clusterBaseUrl;
    }
    get service() {
        if (!this.definition) {
            return undefined;
        }
        if (!this.endpoint) {
            return undefined;
        }
        const { service } = parseEndpoint(this.endpoint);
        return service;
    }
    get stage() {
        if (!this.definition) {
            return undefined;
        }
        if (!this.endpoint) {
            return undefined;
        }
        const { stage } = parseEndpoint(this.endpoint);
        return stage;
    }
    get cluster() {
        if (!this.definition) {
            return undefined;
        }
        if (!this.endpoint) {
            return undefined;
        }
        const { clusterName } = parseEndpoint(this.endpoint);
        return clusterName;
    }
    validate() {
        // shared clusters need a workspace
        const clusterName = this.getClusterName();
        const cluster = this.env.clusterByName(clusterName);
        if (this.definition &&
            clusterName &&
            cluster &&
            cluster.shared &&
            !cluster.isPrivate &&
            !this.getWorkspace() &&
            clusterName !== 'shared-public-demo') {
            throw new Error(`Your \`cluster\` property in the prisma.yml is missing the workspace slug.
Make sure that your \`cluster\` property looks like this: ${chalk.bold('<workspace>/<cluster-name>')}. You can also remove the cluster property from the prisma.yml
and execute ${chalk.bold.green('prisma deploy')} again, to get that value auto-filled.`);
        }
        if (this.definition &&
            this.definition.endpoint &&
            clusterName &&
            cluster &&
            cluster.shared &&
            !cluster.isPrivate &&
            !this.getWorkspace() &&
            clusterName !== 'shared-public-demo') {
            throw new Error(`The provided endpoint ${this.definition.endpoint} points to a demo cluster, but is missing the workspace slug. A valid demo endpoint looks like this: https://eu1.prisma.sh/myworkspace/service-name/stage-name`);
        }
        if (this.definition && this.definition.endpoint && !this.definition.endpoint.startsWith('http')) {
            throw new Error(`${chalk.bold(this.definition.endpoint)} is not a valid endpoint. It must start with http:// or https://`);
        }
    }
    getToken(serviceName, stageName) {
        if (this.secrets) {
            const data = {
                data: {
                    service: `${serviceName}@${stageName}`,
                    roles: ['admin'],
                },
            };
            return sign(data, this.secrets[0], {
                expiresIn: '7d',
            });
        }
        return undefined;
    }
    async getCluster(_ = false) {
        if (this.definition && this.endpoint) {
            const clusterData = parseEndpoint(this.endpoint);
            const cluster = await this.getClusterByEndpoint(clusterData);
            this.env.removeCluster(clusterData.clusterName);
            this.env.addCluster(cluster);
            return cluster;
        }
        return undefined;
    }
    findClusterByBaseUrl(baseUrl) {
        return this.env.clusters.find(c => c.baseUrl.toLowerCase() === baseUrl);
    }
    async getClusterByEndpoint(data) {
        if (data.clusterBaseUrl && !process.env.PRISMA_MANAGEMENT_API_SECRET) {
            const cluster = this.findClusterByBaseUrl(data.clusterBaseUrl);
            if (cluster) {
                return cluster;
            }
        }
        const { clusterName, clusterBaseUrl, isPrivate, local, shared, workspaceSlug } = data;
        // if the cluster could potentially be served by the cloud api, fetch the available
        // clusters from the cloud api
        if (!local) {
            await this.env.fetchClusters();
            const cluster = this.findClusterByBaseUrl(data.clusterBaseUrl);
            if (cluster) {
                return cluster;
            }
        }
        return new Cluster(this.out, clusterName, clusterBaseUrl, shared || isPrivate ? this.env.cloudSessionKey : undefined, local, shared, isPrivate, workspaceSlug);
    }
    getTypesString(definition) {
        const typesPaths = definition.datamodel
            ? Array.isArray(definition.datamodel)
                ? definition.datamodel
                : [definition.datamodel]
            : [];
        let allTypes = '';
        typesPaths.forEach(unresolvedTypesPath => {
            const typesPath = join(this.definitionDir, unresolvedTypesPath);
            try {
                accessSync(typesPath);
                const types = readFileSync(typesPath, 'utf-8');
                allTypes += types + '\n';
            }
            catch (_a) {
                throw new Error(`The types definition file "${typesPath}" could not be found.`);
            }
        });
        return allTypes;
    }
    getClusterName() {
        return this.cluster || null;
    }
    getWorkspace() {
        if (this.definition && this.endpoint) {
            const { workspaceSlug } = parseEndpoint(this.endpoint);
            if (workspaceSlug) {
                return workspaceSlug;
            }
        }
        return null;
    }
    async getDeployName() {
        const cluster = await this.getCluster();
        return concatName(cluster, this.service, this.getWorkspace());
    }
    getSubscriptions() {
        if (this.definition && this.definition.subscriptions) {
            return Object.entries(this.definition.subscriptions).map(([name, subscription]) => {
                const url = typeof subscription.webhook === 'string' ? subscription.webhook : subscription.webhook.url;
                const headers = typeof subscription.webhook === 'string' ? [] : transformHeaders(subscription.webhook.headers);
                let query = subscription.query;
                if (subscription.query.endsWith('.graphql')) {
                    const queryPath = join(this.definitionDir, subscription.query);
                    try {
                        accessSync(queryPath);
                    }
                    catch (_a) {
                        throw new Error(`Subscription query ${queryPath} provided in subscription "${name}" in prisma.yml does not exist.`);
                    }
                    query = readFileSync(queryPath, 'utf-8');
                }
                return {
                    name,
                    query,
                    headers,
                    url,
                };
            });
        }
        return [];
    }
    replaceEndpoint(newEndpoint) {
        this.definitionString = replaceYamlValue(this.definitionString, 'endpoint', newEndpoint);
        writeFileSync(this.definitionPath, this.definitionString);
    }
    addDatamodel(datamodel) {
        this.definitionString += `\ndatamodel: ${datamodel}`;
        writeFileSync(this.definitionPath, this.definitionString);
        this.definition.datamodel = datamodel;
    }
    async getEndpoint(serviceInput, stageInput) {
        const cluster = await this.getCluster();
        const service = serviceInput || this.service;
        const stage = stageInput || this.stage;
        const workspace = this.getWorkspace();
        if (service && stage && cluster) {
            return cluster.getApiEndpoint(service, stage, workspace);
        }
        return null;
    }
    getHooks(hookType) {
        if (this.definition && this.definition.hooks && this.definition.hooks[hookType]) {
            const hooks = this.definition.hooks[hookType];
            if (typeof hooks !== 'string' && !Array.isArray(hooks)) {
                throw new Error(`Hook ${hookType} provided in prisma.yml must be string or an array of strings.`);
            }
            return typeof hooks === 'string' ? [hooks] : hooks;
        }
        return [];
    }
}
function concatName(cluster, name, workspace) {
    if (cluster.shared) {
        const workspaceString = workspace ? `${workspace}~` : '';
        return `${workspaceString}${name}`;
    }
    return name;
}
function transformHeaders(headers) {
    if (!headers) {
        return [];
    }
    return Object.entries(headers).map(([name, value]) => ({ name, value }));
}

class ClusterNotFound extends Error {
    constructor(name) {
        super(`Cluster '${name}' is neither a known shared cluster nor defined in your global .prismarc.`);
    }
}

class ClusterNotSet extends Error {
    constructor() {
        super(`No cluster set. In order to run this command, please set the "cluster" property in your prisma.yml`);
    }
}

const debug$2 = require('debug')('Environment');
class Environment {
    constructor(home, out = new Output(), version) {
        this.sharedClusters = ['prisma-eu1', 'prisma-us1'];
        this.clusterEndpointMap = clusterEndpointMap;
        this.globalRC = {};
        this.clustersFetched = false;
        this.out = out;
        this.home = home;
        this.version = version;
        this.rcPath = join(this.home, '.prisma/config.yml');
        mkdirSync(dirname(this.rcPath), { recursive: true });
    }
    async load() {
        await this.loadGlobalRC();
    }
    get cloudSessionKey() {
        return process.env.PRISMA_CLOUD_SESSION_KEY || this.globalRC.cloudSessionKey;
    }
    async renewToken() {
        if (this.cloudSessionKey) {
            const data = decode(this.cloudSessionKey);
            if (!data.exp) {
                return;
            }
            const timeLeft = data.exp * 1000 - Date.now();
            if (timeLeft < 1000 * 60 * 60 * 24 && timeLeft > 0) {
                try {
                    const res = await this.requestCloudApi(`
          mutation {
            renewToken
          }
        `);
                    if (res.renewToken) {
                        this.globalRC.cloudSessionKey = res.renewToken;
                        this.saveGlobalRC();
                    }
                }
                catch (e) {
                    debug$2(e);
                }
            }
        }
    }
    async fetchClusters() {
        if (!this.clustersFetched && this.cloudSessionKey) {
            const renewPromise = this.renewToken();
            try {
                const res = (await Promise.race([
                    this.requestCloudApi(`
            query prismaCliGetClusters {
              me {
                memberships {
                  workspace {
                    id
                    slug
                    clusters {
                      id
                      name
                      connectInfo {
                        endpoint
                      }
                      customConnectionInfo {
                        endpoint
                      }
                    }
                  }
                }
              }
            }
          `),
                    // eslint-disable-next-line
                    new Promise((_, r) => setTimeout(() => r(), 6000)),
                ]));
                if (!res) {
                    return;
                }
                if (res.me && res.me.memberships && Array.isArray(res.me.memberships)) {
                    // clean up all prisma-eu1 and prisma-us1 clusters if they already exist
                    this.clusters = this.clusters.filter(c => c.name !== 'prisma-eu1' && c.name !== 'prisma-us1');
                    res.me.memberships.forEach((m) => {
                        m.workspace.clusters.forEach((cluster) => {
                            const endpoint = cluster.connectInfo
                                ? cluster.connectInfo.endpoint
                                : cluster.customConnectionInfo
                                    ? cluster.customConnectionInfo.endpoint
                                    : this.clusterEndpointMap[cluster.name];
                            this.addCluster(new Cluster(this.out, cluster.name, endpoint, this.globalRC.cloudSessionKey, false, ['prisma-eu1', 'prisma-us1'].includes(cluster.name), !['prisma-eu1', 'prisma-us1'].includes(cluster.name), m.workspace.slug));
                        });
                    });
                }
            }
            catch (e) {
                debug$2(e);
            }
            await renewPromise;
        }
    }
    clusterByName(name, throws = false) {
        if (!this.clusters) {
            return;
        }
        const cluster = this.clusters.find(c => c.name === name);
        if (!throws) {
            return cluster;
        }
        if (!cluster) {
            if (!name) {
                throw new ClusterNotSet();
            }
            throw new ClusterNotFound(name);
        }
        return cluster;
    }
    setToken(token) {
        this.globalRC.cloudSessionKey = token;
    }
    addCluster(cluster) {
        const existingClusterIndex = this.clusters.findIndex(c => {
            if (cluster.workspaceSlug) {
                return c.workspaceSlug === cluster.workspaceSlug && c.name === cluster.name;
            }
            else {
                return c.name === cluster.name;
            }
        });
        if (existingClusterIndex > -1) {
            this.clusters.splice(existingClusterIndex, 1);
        }
        this.clusters.push(cluster);
    }
    removeCluster(name) {
        this.clusters = this.clusters.filter(c => c.name !== name);
    }
    saveGlobalRC() {
        const rc = {
            cloudSessionKey: this.globalRC.cloudSessionKey ? this.globalRC.cloudSessionKey.trim() : undefined,
            clusters: this.getLocalClusterConfig(),
        };
        // parse & stringify to rm undefined for yaml parser
        const rcString = safeDump(JSON.parse(JSON.stringify(rc)));
        writeFileSync(this.rcPath, rcString);
    }
    setActiveCluster(cluster) {
        this.activeCluster = cluster;
    }
    async loadGlobalRC() {
        if (this.rcPath) {
            try {
                accessSync(this.rcPath);
                const globalFile = readFileSync(this.rcPath, 'utf-8');
                await this.parseGlobalRC(globalFile);
            }
            catch (_a) {
                await this.parseGlobalRC();
            }
        }
        else {
            await this.parseGlobalRC();
        }
    }
    async parseGlobalRC(globalFile) {
        if (globalFile) {
            this.globalRC = await this.loadYaml(globalFile, this.rcPath);
        }
        this.clusters = this.initClusters(this.globalRC);
    }
    async loadYaml(file, filePath = null) {
        if (file) {
            let content;
            try {
                content = safeLoad(file);
            }
            catch (e) {
                throw new Error(`Yaml parsing error in ${filePath}: ${e.message}`);
            }
            const variables = new Variables(filePath || 'no filepath provided', this.args, this.out);
            content = await variables.populateJson(content);
            return content;
        }
        else {
            return {};
        }
    }
    initClusters(rc) {
        const sharedClusters = this.getSharedClusters(rc);
        return [...sharedClusters];
    }
    getSharedClusters(rc) {
        return this.sharedClusters.map(clusterName => {
            return new Cluster(this.out, clusterName, this.clusterEndpointMap[clusterName], rc && rc.cloudSessionKey, false, true);
        });
    }
    getLocalClusterConfig() {
        return this.clusters
            .filter(c => !c.shared && c.clusterSecret !== this.cloudSessionKey && !c.isPrivate)
            .reduce((acc, cluster) => {
            return {
                ...acc,
                [cluster.name]: {
                    host: cluster.baseUrl,
                    clusterSecret: cluster.clusterSecret,
                },
            };
        }, {});
    }
    async requestCloudApi(query) {
        const res = await fetch('https://api.cloud.prisma.sh', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                Authorization: `Bearer ${this.cloudSessionKey}`,
                'X-Cli-Version': this.version,
            },
            body: JSON.stringify({
                query,
            }),
            proxy: getProxyAgent('https://api.cloud.prisma.sh'),
        });
        const json = await res.json();
        return json.data;
    }
}

const { access } = promises;
/**
 * This loader loads a schema from a `prisma.yml` file
 */
class PrismaLoader extends UrlLoader {
    loaderId() {
        return 'prisma';
    }
    async canLoad(prismaConfigFilePath, options) {
        if (typeof prismaConfigFilePath === 'string' && prismaConfigFilePath.endsWith('prisma.yml')) {
            const joinedYmlPath = join(options.cwd || cwd(), prismaConfigFilePath);
            try {
                await access(joinedYmlPath);
                return true;
            }
            catch (_a) {
                return false;
            }
        }
        return false;
    }
    async load(prismaConfigFilePath, options) {
        const { graceful, envVars } = options;
        const home = homedir();
        const env = new Environment(home);
        await env.load();
        const joinedYmlPath = join(options.cwd || cwd(), prismaConfigFilePath);
        const definition = new PrismaDefinitionClass(env, joinedYmlPath, envVars);
        await definition.load({}, undefined, graceful);
        const serviceName = definition.service;
        const stage = definition.stage;
        const clusterName = definition.cluster;
        if (!clusterName) {
            throw new Error(`No cluster set. Please set the "cluster" property in your prisma.yml`);
        }
        const cluster = await definition.getCluster();
        if (!cluster) {
            throw new Error(`Cluster ${clusterName} provided in prisma.yml could not be found in global ~/.prisma/config.yml.
      Please check in ~/.prisma/config.yml, if the cluster exists.
      You can use \`docker-compose up -d\` to start a new cluster.`);
        }
        const token = definition.getToken(serviceName, stage);
        const url = cluster.getApiEndpoint(serviceName, stage, definition.getWorkspace() || undefined);
        const headers = token
            ? {
                Authorization: `Bearer ${token}`,
            }
            : undefined;
        return super.load(url, { headers });
    }
}

export { PrismaLoader };
//# sourceMappingURL=index.esm.js.map