@google/clasp 2.5.0 → 3.0.0-alpha1

package/build/src/core/project.js

@@ -0,0 +1,313 @@
+import Debug from 'debug';
+import fs from 'fs/promises';
+import { google } from 'googleapis';
+import { fetchWithPages } from './utils.js';
+import { assertAuthenticated, assertScriptConfigured, handleApiError } from './utils.js';
+import path from 'path';
+const debug = Debug('clasp:core');
+export class Project {
+    constructor(options) {
+        this.options = options;
+    }
+    get scriptId() {
+        var _a;
+        return (_a = this.options.project) === null || _a === void 0 ? void 0 : _a.scriptId;
+    }
+    get projectId() {
+        var _a;
+        return (_a = this.options.project) === null || _a === void 0 ? void 0 : _a.projectId;
+    }
+    get parentId() {
+        var _a;
+        return (_a = this.options.project) === null || _a === void 0 ? void 0 : _a.parentId;
+    }
+    // TODO - Do we need the assertion or can just use accessor?
+    getProjectId() {
+        assertScriptConfigured(this.options);
+        return this.options.project.projectId;
+    }
+    async createScript(name, parentId) {
+        var _a;
+        debug('Creating script %s', name);
+        assertAuthenticated(this.options);
+        if ((_a = this.options.project) === null || _a === void 0 ? void 0 : _a.scriptId) {
+            debug('Warning: Creating script while id already exists');
+        }
+        const credentials = this.options.credentials;
+        const script = google.script({ version: 'v1', auth: credentials });
+        try {
+            const requestOptions = {
+                requestBody: {
+                    parentId,
+                    title: name,
+                },
+            };
+            debug('Creating project with request %O', requestOptions);
+            const res = await script.projects.create(requestOptions);
+            if (!res.data.scriptId) {
+                throw new Error('Unexpected error, script ID missing from response.');
+            }
+            debug('Created script %s', res.data.scriptId);
+            const scriptId = res.data.scriptId;
+            this.options.project = { scriptId, parentId };
+            return scriptId;
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    }
+    async createWithContainer(name, mimeType) {
+        var _a;
+        debug('Creating container bound script %s (%s)', name, mimeType);
+        assertAuthenticated(this.options);
+        if ((_a = this.options.project) === null || _a === void 0 ? void 0 : _a.scriptId) {
+            debug('Warning: Creating script while id already exists');
+        }
+        let parentId;
+        const credentials = this.options.credentials;
+        const drive = google.drive({ version: 'v3', auth: credentials });
+        try {
+            const requestOptions = {
+                requestBody: {
+                    mimeType,
+                    name,
+                },
+            };
+            debug('Creating project with request %O', requestOptions);
+            const res = await drive.files.create(requestOptions);
+            parentId = res.data.id;
+            debug('Created container %s', parentId);
+            if (!parentId) {
+                throw new Error('Unexpected error, container ID missing from response.');
+            }
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+        const scriptId = await this.createScript(name, parentId);
+        return {
+            parentId,
+            scriptId,
+        };
+    }
+    async listScripts() {
+        debug('Fetching scripts');
+        assertAuthenticated(this.options);
+        const credentials = this.options.credentials;
+        const drive = google.drive({ version: 'v3', auth: credentials });
+        try {
+            return fetchWithPages(async (pageSize, pageToken) => {
+                var _a, _b;
+                const requestOptions = {
+                    pageSize,
+                    pageToken,
+                    fields: 'nextPageToken, files(id, name)',
+                    q: 'mimeType="application/vnd.google-apps.script"',
+                };
+                debug('Fetching scripts from drive with request %O', requestOptions);
+                const res = await drive.files.list(requestOptions);
+                return {
+                    results: ((_a = res.data.files) !== null && _a !== void 0 ? _a : []),
+                    pageToken: (_b = res.data.nextPageToken) !== null && _b !== void 0 ? _b : undefined,
+                };
+            });
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    }
+    async version(description = '') {
+        var _a;
+        debug('Creating version: %s', description);
+        assertAuthenticated(this.options);
+        assertScriptConfigured(this.options);
+        const credentials = this.options.credentials;
+        const scriptId = this.options.project.scriptId;
+        const script = google.script({ version: 'v1', auth: credentials });
+        try {
+            const requestOptions = {
+                requestBody: {
+                    description: description !== null && description !== void 0 ? description : '',
+                },
+                scriptId: scriptId,
+            };
+            debug('Creating version with request %O', requestOptions);
+            const res = await script.projects.versions.create(requestOptions);
+            const versionNumber = (_a = res.data.versionNumber) !== null && _a !== void 0 ? _a : 0;
+            debug('Created new version %d', versionNumber);
+            return versionNumber;
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    }
+    async listVersions() {
+        debug('Fetching versions');
+        assertAuthenticated(this.options);
+        assertScriptConfigured(this.options);
+        const scriptId = this.options.project.scriptId;
+        const credentials = this.options.credentials;
+        const script = google.script({ version: 'v1', auth: credentials });
+        try {
+            return fetchWithPages(async (pageSize, pageToken) => {
+                var _a, _b;
+                const requestOptions = {
+                    scriptId,
+                    pageSize,
+                    pageToken,
+                };
+                debug('Fetching versions with request %O', requestOptions);
+                const res = await script.projects.versions.list(requestOptions);
+                return {
+                    results: (_a = res.data.versions) !== null && _a !== void 0 ? _a : [],
+                    pageToken: (_b = res.data.nextPageToken) !== null && _b !== void 0 ? _b : undefined,
+                };
+            });
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    }
+    async listDeployments() {
+        debug('Listing deployments');
+        assertAuthenticated(this.options);
+        assertScriptConfigured(this.options);
+        const scriptId = this.options.project.scriptId;
+        const credentials = this.options.credentials;
+        const script = google.script({ version: 'v1', auth: credentials });
+        try {
+            return fetchWithPages(async (pageSize, pageToken) => {
+                var _a, _b;
+                const requestOptions = {
+                    scriptId,
+                    pageSize,
+                    pageToken,
+                };
+                debug('Fetching deployments with request %O', requestOptions);
+                const res = await script.projects.deployments.list(requestOptions);
+                return {
+                    results: (_a = res.data.deployments) !== null && _a !== void 0 ? _a : [],
+                    pageToken: (_b = res.data.nextPageToken) !== null && _b !== void 0 ? _b : undefined,
+                };
+            });
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    }
+    async deploy(description = '', deploymentId, versionNumber) {
+        debug('Deploying project: %s (%s)', description, versionNumber !== null && versionNumber !== void 0 ? versionNumber : 'HEAD');
+        assertAuthenticated(this.options);
+        assertScriptConfigured(this.options);
+        if (versionNumber === undefined) {
+            versionNumber = await this.version(description);
+        }
+        const scriptId = this.options.project.scriptId;
+        const credentials = this.options.credentials;
+        const script = google.script({ version: 'v1', auth: credentials });
+        try {
+            let deployment;
+            if (!deploymentId) {
+                const requestOptions = {
+                    scriptId: scriptId,
+                    requestBody: {
+                        description: description !== null && description !== void 0 ? description : '',
+                        versionNumber: versionNumber,
+                        manifestFileName: 'appsscript',
+                    },
+                };
+                debug('Creating deployment with request %O', requestOptions);
+                const res = await script.projects.deployments.create(requestOptions);
+                deployment = res.data;
+            }
+            else {
+                const requestOptions = {
+                    scriptId: scriptId,
+                    deploymentId: deploymentId,
+                    requestBody: {
+                        deploymentConfig: {
+                            description: description !== null && description !== void 0 ? description : '',
+                            versionNumber: versionNumber,
+                            scriptId: scriptId,
+                            manifestFileName: 'appsscript',
+                        },
+                    },
+                };
+                debug('Updating existing deployment with request %O', requestOptions);
+                const res = await script.projects.deployments.update(requestOptions);
+                deployment = res.data;
+            }
+            return deployment;
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    }
+    async entryPoints(deploymentId) {
+        var _a, _b;
+        assertAuthenticated(this.options);
+        assertScriptConfigured(this.options);
+        const scriptId = this.options.project.scriptId;
+        const credentials = this.options.credentials;
+        const script = google.script({ version: 'v1', auth: credentials });
+        try {
+            const res = await script.projects.deployments.get({ scriptId, deploymentId });
+            const entryPoints = (_b = (_a = res.data) === null || _a === void 0 ? void 0 : _a.entryPoints) !== null && _b !== void 0 ? _b : [];
+            return entryPoints;
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    }
+    async undeploy(deploymentId) {
+        debug('Deleting deployment %s', deploymentId);
+        assertAuthenticated(this.options);
+        assertScriptConfigured(this.options);
+        const scriptId = this.options.project.scriptId;
+        const credentials = this.options.credentials;
+        const script = google.script({ version: 'v1', auth: credentials });
+        try {
+            const requestOptions = {
+                scriptId: scriptId,
+                deploymentId,
+            };
+            debug('Deleting deployment with request %O', requestOptions);
+            await script.projects.deployments.delete(requestOptions);
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    }
+    async updateSettings() {
+        debug('Updating settings');
+        assertScriptConfigured(this.options);
+        const srcDir = path.relative(this.options.files.projectRootDir, this.options.files.contentDir);
+        const settings = {
+            scriptId: this.options.project.scriptId,
+            rootDir: srcDir,
+            projectId: this.options.project.projectId,
+            fileExtension: this.options.files.fileExtension,
+            filePushOrder: [],
+        };
+        await fs.writeFile(this.options.configFilePath, JSON.stringify(settings, null, 2));
+    }
+    async setProjectId(projectId) {
+        debug('Setting project ID %s in file %s', projectId, this.options.configFilePath);
+        assertScriptConfigured(this.options);
+        this.options.project.projectId = projectId;
+        this.updateSettings();
+    }
+    exists() {
+        var _a;
+        return ((_a = this.options.project) === null || _a === void 0 ? void 0 : _a.scriptId) !== undefined;
+    }
+    async readManifest() {
+        debug('Reading manifest');
+        assertScriptConfigured(this.options);
+        const manifestPath = path.join(this.options.files.contentDir, 'appsscript.json');
+        debug('Manifest path is %s', manifestPath);
+        const content = await fs.readFile(manifestPath);
+        const manifest = JSON.parse(content.toString());
+        return manifest;
+    }
+}

package/build/src/core/services.js

@@ -0,0 +1,179 @@
+import path from 'path';
+import Debug from 'debug';
+import fs from 'fs/promises';
+import { google } from 'googleapis';
+import { PUBLIC_ADVANCED_SERVICES } from './apis.js';
+import { assertGcpProjectConfigured, handleApiError } from './utils.js';
+import { fetchWithPages } from './utils.js';
+const debug = Debug('clasp:core');
+export class Services {
+    constructor(config) {
+        this.options = config;
+    }
+    async getEnabledServices() {
+        debug('Fetching enabled services');
+        assertGcpProjectConfigured(this.options);
+        const projectId = this.options.project.projectId;
+        const serviceUsage = google.serviceusage({ version: 'v1', auth: this.options.credentials });
+        try {
+            const serviceList = await fetchWithPages(async (pageSize, pageToken) => {
+                var _a, _b;
+                const requestOptions = {
+                    parent: `projects/${projectId}`,
+                    filter: 'state:ENABLED',
+                    pageSize,
+                    pageToken,
+                };
+                debug('Fetching available APIs with request %O', requestOptions);
+                const res = await serviceUsage.services.list(requestOptions);
+                return {
+                    results: (_a = res.data.services) !== null && _a !== void 0 ? _a : [],
+                    pageToken: (_b = res.data.nextPageToken) !== null && _b !== void 0 ? _b : undefined,
+                };
+            }, {
+                pageSize: 200,
+                maxResults: 10000,
+            });
+            // Filter out the disabled ones. Print the enabled ones.
+            const truncateName = (name) => {
+                const i = name.indexOf('.');
+                if (i !== -1) {
+                    return name.slice(0, i);
+                }
+                return name;
+            };
+            const allowedIds = PUBLIC_ADVANCED_SERVICES.map(service => service.serviceId);
+            return serviceList.results
+                .map(service => {
+                var _a, _b, _c, _d, _e, _f;
+                return ({
+                    id: (_a = service.name) !== null && _a !== void 0 ? _a : '',
+                    name: truncateName((_c = (_b = service.config) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : 'Unknown name'),
+                    description: (_f = (_e = (_d = service.config) === null || _d === void 0 ? void 0 : _d.documentation) === null || _e === void 0 ? void 0 : _e.summary) !== null && _f !== void 0 ? _f : '',
+                });
+            })
+                .filter(service => {
+                return allowedIds.indexOf(service.name) !== -1;
+            });
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    }
+    async getAvailableServices() {
+        var _a;
+        debug('Fetching available services');
+        const discovery = google.discovery({ version: 'v1' });
+        try {
+            const { data } = await discovery.apis.list({
+                preferred: true,
+            });
+            const allowedIds = PUBLIC_ADVANCED_SERVICES.map(service => service.serviceId);
+            const allServices = (_a = data.items) !== null && _a !== void 0 ? _a : [];
+            const isValidService = (s) => {
+                return (s.id !== undefined && s.name !== undefined && allowedIds.indexOf(s.name) !== -1 && s.description !== undefined);
+            };
+            const services = allServices.filter(isValidService).sort((a, b) => a.id.localeCompare(b.id));
+            debug('Available services: %O', services);
+            return services;
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    }
+    async enableService(serviceName) {
+        var _a;
+        debug('Enabling service %s', serviceName);
+        assertGcpProjectConfigured(this.options);
+        const projectId = this.options.project.projectId;
+        const contentDir = this.options.files.contentDir;
+        if (!serviceName) {
+            throw new Error('No service name provided.');
+        }
+        const manifestPath = path.join(contentDir, 'appsscript.json');
+        const manifestExists = await hasReadWriteAccess(manifestPath);
+        if (!manifestExists) {
+            debug('Manifest file at %s does not exist', manifestPath);
+            throw new Error('Manifest file does not exist.');
+        }
+        const advancedService = PUBLIC_ADVANCED_SERVICES.find(service => service.serviceId === serviceName);
+        if (!advancedService) {
+            throw new Error('Service is not a valid advanced service.');
+        }
+        // Do not update manifest if not valid advanced service
+        debug('Service is an advanced service, updating manifest');
+        const content = await fs.readFile(manifestPath);
+        const manifest = JSON.parse(content.toString());
+        if ((_a = manifest.dependencies) === null || _a === void 0 ? void 0 : _a.enabledAdvancedServices) {
+            if (manifest.dependencies.enabledAdvancedServices.findIndex(s => s.userSymbol === advancedService.userSymbol) === -1) {
+                manifest.dependencies.enabledAdvancedServices.push(advancedService);
+            }
+        }
+        else if (manifest.dependencies) {
+            manifest.dependencies.enabledAdvancedServices = [advancedService];
+        }
+        else {
+            manifest.dependencies = { enabledAdvancedServices: [advancedService] };
+        }
+        debug('Updating manifest at %s with %j', manifestPath, manifest);
+        await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+        debug('Enabling GCP service %s.googleapis.com', serviceName);
+        const serviceUsage = google.serviceusage({ version: 'v1', auth: this.options.credentials });
+        const resourceName = `projects/${projectId}/services/${serviceName}.googleapis.com`;
+        try {
+            await serviceUsage.services.enable({ name: resourceName });
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    }
+    async disableService(serviceName) {
+        var _a;
+        debug('Disabling service %s', serviceName);
+        assertGcpProjectConfigured(this.options);
+        const projectId = this.options.project.projectId;
+        const contentDir = this.options.files.contentDir;
+        if (!serviceName) {
+            throw new Error('No service name provided.');
+        }
+        const manifestPath = path.join(contentDir, 'appsscript.json');
+        const manifestExists = await hasReadWriteAccess(manifestPath);
+        if (!manifestExists) {
+            debug('Manifest file at %s does not exist', manifestPath);
+            throw new Error('Manifest file does not exist.');
+        }
+        const advancedService = PUBLIC_ADVANCED_SERVICES.find(service => service.serviceId === serviceName);
+        if (!advancedService) {
+            throw new Error('Service is not a valid advanced service.');
+        }
+        // Do not update manifest if not valid advanced service
+        debug('Service is an advanced service, updating manifest');
+        const content = await fs.readFile(manifestPath);
+        const manifest = JSON.parse(content.toString());
+        if (!((_a = manifest.dependencies) === null || _a === void 0 ? void 0 : _a.enabledAdvancedServices)) {
+            debug('Service enabled in manifest, skipping manifest update');
+            return;
+        }
+        manifest.dependencies.enabledAdvancedServices = manifest.dependencies.enabledAdvancedServices.filter(service => service.serviceId !== serviceName);
+        debug('Updating manifest at %s with %j', manifestPath, manifest);
+        await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+        debug('Disabling GCP service %s.googleapis.com', serviceName);
+        const serviceUsage = google.serviceusage({ version: 'v1', auth: this.options.credentials });
+        const resourceName = `projects/${projectId}/services/${serviceName}.googleapis.com`;
+        try {
+            await serviceUsage.services.disable({ name: resourceName });
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    }
+}
+async function hasReadWriteAccess(path) {
+    try {
+        await fs.access(path, fs.constants.W_OK | fs.constants.R_OK);
+    }
+    catch {
+        return false;
+    }
+    return true;
+}

package/build/src/core/utils.js

@@ -0,0 +1,121 @@
+import Debug from 'debug';
+import { GaxiosError } from 'googleapis-common';
+const debug = Debug('clasp:core');
+export function assertAuthenticated(options) {
+    if (!options.credentials) {
+        debug('Credentials not set in options: %O', options);
+        throw new Error('No credentials found.', {
+            cause: {
+                code: 'NO_CREDENTIALS',
+            },
+        });
+    }
+}
+export function assertScriptConfigured(options) {
+    var _a;
+    if (!((_a = options.project) === null || _a === void 0 ? void 0 : _a.scriptId) ||
+        !options.files.projectRootDir ||
+        !options.configFilePath ||
+        !options.files.contentDir) {
+        debug('Script configuration not found in options: %O', options);
+        throw new Error('Project settings not found.', {
+            cause: {
+                code: 'MISSING_SCRIPT_CONFIGURATION',
+            },
+        });
+    }
+}
+export function assertGcpProjectConfigured(options) {
+    var _a;
+    assertScriptConfigured(options);
+    if (!((_a = options.project) === null || _a === void 0 ? void 0 : _a.projectId)) {
+        debug('Script configuration not found in options: %O', options);
+        throw new Error('Project ID not found.', {
+            cause: {
+                code: 'MISSING_PROJECT_ID',
+            },
+        });
+    }
+}
+function pageOptionsWithDefaults(options) {
+    return {
+        pageSize: 100,
+        maxPages: 10,
+        maxResults: Number.MAX_SAFE_INTEGER,
+        ...(options !== null && options !== void 0 ? options : {}),
+    };
+}
+export async function fetchWithPages(fn, options) {
+    const { pageSize, maxPages, maxResults } = pageOptionsWithDefaults(options);
+    let pageToken = undefined;
+    let pageCount = 0;
+    const results = [];
+    do {
+        debug('Fetching page %d', pageCount + 1);
+        const page = await fn(pageSize, pageToken);
+        if (page.results) {
+            results.push(...page.results);
+        }
+        ++pageCount;
+        pageToken = page.pageToken;
+    } while (pageToken && pageCount < maxPages && results.length < maxResults);
+    if (pageToken) {
+        debug('Returning partial results, page limit exceeded');
+    }
+    if (results.length > maxResults) {
+        debug('Trimming results to %d', maxResults);
+        return {
+            results: results.slice(0, maxResults),
+            partialResults: true,
+        };
+    }
+    return {
+        results,
+        partialResults: pageToken !== undefined,
+    };
+}
+function isDetailedError(error) {
+    if (!error) {
+        return false;
+    }
+    const detailedError = error;
+    if (detailedError.errors === undefined) {
+        return false;
+    }
+    if (detailedError.errors.length === 0) {
+        return false;
+    }
+    return true;
+}
+const ERROR_CODES = {
+    400: 'INVALID_ARGUMENT',
+    401: 'NOT_AUTHENTICATED',
+    403: 'NOT_AUTHORIZED',
+    404: 'NOT_FOUND',
+};
+export function handleApiError(error) {
+    var _a;
+    debug('Handling API error: %O', error);
+    if (!(error instanceof GaxiosError)) {
+        throw new Error('Unexpected error', {
+            cause: {
+                code: 'UNEPECTED_ERROR',
+                message: String(error),
+                error: error,
+            },
+        });
+    }
+    const status = error.status;
+    let message = error.message;
+    if (isDetailedError(error)) {
+        message = error.errors[0].message;
+    }
+    const code = (_a = ERROR_CODES[status !== null && status !== void 0 ? status : 0]) !== null && _a !== void 0 ? _a : 'UNEXPECTED_API_ERROR';
+    throw new Error(message, {
+        cause: {
+            code: code,
+            message: message,
+            error: error,
+        },
+    });
+}