@google/clasp 2.5.0 → 3.0.0-alpha1

package/build/src/core/files.js

@@ -0,0 +1,359 @@
+import path from 'path';
+import chalk from 'chalk';
+import chokidar from 'chokidar';
+import Debug from 'debug';
+import { fdir } from 'fdir';
+import fs from 'fs/promises';
+import { google } from 'googleapis';
+import { GaxiosError } from 'googleapis-common';
+import micromatch from 'micromatch';
+import normalizePath from 'normalize-path';
+import pMap from 'p-map';
+import { assertAuthenticated, assertScriptConfigured, handleApiError } from './utils.js';
+const debug = Debug('clasp:core');
+function parentDirs(file) {
+    const parentDirs = [];
+    let currentDir = path.dirname(file);
+    while (currentDir !== '.') {
+        parentDirs.push(currentDir);
+        currentDir = path.dirname(currentDir);
+    }
+    return parentDirs;
+}
+async function getLocalFiles(rootDir, ignorePatterns, recursive) {
+    debug('Collecting files in %s', rootDir);
+    let fdirBuilder = new fdir().withBasePath().withRelativePaths();
+    if (!recursive) {
+        debug('Not recursive, limiting depth to current directory');
+        fdirBuilder = fdirBuilder.withMaxDepth(0);
+    }
+    const files = await fdirBuilder.crawl(rootDir).withPromise();
+    const filteredFiles = micromatch.not(files, ignorePatterns, { dot: true });
+    debug('Filtered %d files from ignore rules', files.length - filteredFiles.length);
+    filteredFiles.sort((a, b) => a.localeCompare(b));
+    return filteredFiles[Symbol.iterator]();
+}
+async function getUnfilteredLocalFiles(rootDir) {
+    debug('Collecting files in %s', rootDir);
+    const fdirBuilder = new fdir().withBasePath();
+    const files = await fdirBuilder.crawl(rootDir).withPromise();
+    files.sort((a, b) => a.localeCompare(b));
+    return files[Symbol.iterator]();
+}
+function createFilenameConflictChecker() {
+    const files = new Set();
+    return (file) => {
+        if (file.type !== 'SERVER_JS') {
+            return file;
+        }
+        const parsedPath = path.parse(file.localPath);
+        const key = path.format({ dir: parsedPath.dir, name: parsedPath.name });
+        if (files.has(key)) {
+            throw new Error('Conflicting files found', {
+                cause: {
+                    code: 'FILE_CONFLICT',
+                    value: key,
+                },
+            });
+        }
+        return file;
+    };
+}
+function getFileType(fileName) {
+    const extension = path.extname(fileName).toUpperCase();
+    if (['.GS', '.JS'].includes(extension)) {
+        return 'SERVER_JS';
+    }
+    if (extension === '.JSON' && path.basename(fileName) === 'appsscript.json') {
+        return 'JSON';
+    }
+    if (extension === '.HTML') {
+        return 'HTML';
+    }
+    return undefined;
+}
+function getFileExtension(type) {
+    // TODO - Include project setting override
+    switch (type) {
+        case 'SERVER_JS':
+            return 'js';
+        case 'JSON':
+            return 'json';
+        case 'HTML':
+            return 'html';
+        default:
+            throw new Error('Invalid file type', {
+                cause: {
+                    code: 'INVALID_FILE_TYPE',
+                    value: type,
+                },
+            });
+    }
+}
+function debounceFileChanges(callback, delayMs) {
+    let timeoutId;
+    let collectedPaths = [];
+    return function (path) {
+        // Already tracked as changed, ignore
+        if (collectedPaths.includes(path)) {
+            return;
+        }
+        collectedPaths.push(path);
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => {
+            callback(collectedPaths);
+            collectedPaths = [];
+        }, delayMs);
+    };
+}
+export class Files {
+    constructor(options) {
+        this.options = options;
+    }
+    async fetchRemote(versionNumber) {
+        var _a;
+        debug('Fetching remote files, version %s', versionNumber !== null && versionNumber !== void 0 ? versionNumber : 'HEAD');
+        assertAuthenticated(this.options);
+        assertScriptConfigured(this.options);
+        const credentials = this.options.credentials;
+        const contentDir = this.options.files.contentDir;
+        const scriptId = this.options.project.scriptId;
+        const script = google.script({ version: 'v1', auth: credentials });
+        try {
+            const requestOptions = { scriptId, versionNumber };
+            debug('Fetchign script content, request %o', requestOptions);
+            const response = await script.projects.getContent(requestOptions);
+            const files = (_a = response.data.files) !== null && _a !== void 0 ? _a : [];
+            return files.map(f => {
+                var _a, _b, _c;
+                const ext = getFileExtension(f.type);
+                const localPath = path.relative(process.cwd(), path.resolve(contentDir, `${f.name}.${ext}`));
+                const file = {
+                    localPath: localPath,
+                    remotePath: (_a = f.name) !== null && _a !== void 0 ? _a : undefined,
+                    source: (_b = f.source) !== null && _b !== void 0 ? _b : undefined,
+                    type: (_c = f.type) !== null && _c !== void 0 ? _c : undefined,
+                };
+                debug('Fetched file %O', file);
+                return file;
+            });
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    }
+    async collectLocalFiles() {
+        var _a;
+        debug('Collecting local files');
+        assertScriptConfigured(this.options);
+        const contentDir = this.options.files.contentDir;
+        const ignorePatterns = (_a = this.options.files.ignorePatterns) !== null && _a !== void 0 ? _a : [];
+        const recursive = this.options.files.ignoreFilePath !== undefined;
+        // Read all filenames as a flattened tree
+        // Note: filePaths contain relative paths such as "test/bar.ts", "../../src/foo.js"
+        const filelist = await getLocalFiles(contentDir, ignorePatterns, recursive);
+        const checkDuplicate = createFilenameConflictChecker();
+        const files = await Promise.all(filelist.map(async (filename) => {
+            const localPath = path.relative(process.cwd(), path.join(contentDir, filename));
+            const resolvedPath = path.relative(contentDir, localPath);
+            const parsedPath = path.parse(resolvedPath);
+            let remotePath = path.format({ dir: normalizePath(parsedPath.dir), name: parsedPath.name });
+            const type = getFileType(localPath);
+            if (!type) {
+                debug('Ignoring unsupported file %s', localPath);
+                return undefined;
+            }
+            if (type === 'JSON' && path.basename(localPath) === 'appsscript.json') {
+                // Manifest has a fixed path in script
+                remotePath = 'appsscript';
+            }
+            const content = await fs.readFile(localPath);
+            const source = content.toString();
+            return checkDuplicate({ localPath, remotePath, source, type });
+        }));
+        return files.filter((f) => f !== undefined);
+    }
+    watchLocalFiles(onReady, onFilesChanged) {
+        var _a;
+        const ignorePatterns = (_a = this.options.files.ignorePatterns) !== null && _a !== void 0 ? _a : [];
+        const collector = debounceFileChanges(onFilesChanged, 500);
+        const onChange = async (path) => {
+            collector(path);
+        };
+        const watcher = chokidar.watch(this.options.files.contentDir, {
+            persistent: true,
+            ignoreInitial: true,
+            cwd: this.options.files.contentDir,
+            ignored: file => {
+                return micromatch.not([file], ignorePatterns, { dot: true }).length === 0;
+            },
+        });
+        watcher.on('ready', onReady); // Push on start
+        watcher.on('add', onChange);
+        watcher.on('change', onChange);
+        watcher.on('unlink', onChange);
+        return async () => await watcher.close();
+    }
+    async getChangedFiles() {
+        const [localFiles, remoteFiles] = await Promise.all([this.collectLocalFiles(), this.fetchRemote()]);
+        return localFiles.reduce((changed, localFile) => {
+            const remote = remoteFiles.find(f => f.localPath === localFile.localPath);
+            if (!remote || remote.source !== localFile.source) {
+                changed.push(localFile);
+            }
+            return changed;
+        }, []);
+    }
+    async getUntrackedFiles() {
+        debug('Collecting untracked files');
+        assertScriptConfigured(this.options);
+        const contentDir = this.options.files.contentDir;
+        const cwd = process.cwd();
+        const dirsWithIncludedFiles = new Set();
+        const trackedFiles = new Set();
+        const untrackedFiles = new Set();
+        const projectFiles = await this.collectLocalFiles();
+        for (const file of projectFiles) {
+            debug('Found tracked file %s', file.localPath);
+            trackedFiles.add(file.localPath);
+            // Save all parent paths to allow quick lookup.
+            // Allows collapsing the unfiltered files to the common parent directory
+            const dirs = parentDirs(file.localPath);
+            dirs.forEach(dir => dirsWithIncludedFiles.add(dir));
+        }
+        const allFiles = await getUnfilteredLocalFiles(contentDir);
+        for (const file of allFiles) {
+            const resolvedPath = path.relative(cwd, file);
+            if (trackedFiles.has(resolvedPath)) {
+                // Tracked file, skip
+                continue;
+            }
+            // Reduce path to nearest parent directory with no project files included
+            let excludedPath = resolvedPath;
+            for (const dir of parentDirs(resolvedPath)) {
+                if (dirsWithIncludedFiles.has(dir)) {
+                    break;
+                }
+                excludedPath = `${dir}/`;
+            }
+            debug('Found untracked file %s', excludedPath);
+            untrackedFiles.add(excludedPath);
+        }
+        const untrackedFilesArray = Array.from(untrackedFiles);
+        untrackedFilesArray.sort((a, b) => a.localeCompare(b));
+        return untrackedFilesArray;
+    }
+    async push() {
+        var _a;
+        debug('Pushing files');
+        assertAuthenticated(this.options);
+        assertScriptConfigured(this.options);
+        const credentials = this.options.credentials;
+        const scriptId = this.options.project.scriptId;
+        const files = await this.collectLocalFiles();
+        if (!files || files.length === 0) {
+            debug('No files found to push.');
+            return [];
+        }
+        const filePushOrder = (_a = this.options.files.filePushOrder) !== null && _a !== void 0 ? _a : [];
+        files.sort((a, b) => {
+            const indexA = filePushOrder.indexOf(a.localPath);
+            const indexB = filePushOrder.indexOf(b.localPath);
+            if (indexA === -1 && indexB === -1) {
+                // Neither has explicit order, sort by name
+                return a.localPath.localeCompare(b.localPath);
+            }
+            if (indexA === -1) {
+                // B has explicit priority, is first
+                return 1;
+            }
+            if (indexB === -1) {
+                // A has explicit priority, is first
+                return -1;
+            }
+            // Both prioritized, use rank
+            return indexA - indexB;
+        });
+        // Start pushing.
+        try {
+            const scriptFiles = files.map(f => ({
+                name: f.remotePath,
+                type: f.type,
+                source: f.source,
+            }));
+            const script = google.script({ version: 'v1', auth: credentials });
+            const requestOptions = {
+                scriptId,
+                requestBody: {
+                    files: scriptFiles,
+                },
+            };
+            debug('Updating content, request %O', requestOptions);
+            await script.projects.updateContent(requestOptions);
+            return files;
+        }
+        catch (error) {
+            debug(error);
+            if (error instanceof GaxiosError) {
+                const syntaxError = extractSyntaxError(error, files);
+                if (syntaxError) {
+                    throw new Error(syntaxError.message, {
+                        cause: {
+                            code: 'SYNTAX_ERROR',
+                            error: error,
+                            snippet: syntaxError.snippet,
+                        },
+                    });
+                }
+            }
+            handleApiError(error);
+        }
+    }
+    async pull(version) {
+        debug('Pulling files');
+        assertAuthenticated(this.options);
+        assertScriptConfigured(this.options);
+        const files = await this.fetchRemote(version);
+        await this.WriteFiles(files);
+        return files;
+    }
+    async WriteFiles(files) {
+        debug('Writing files');
+        const mapper = async (file) => {
+            debug('Write file %s', path.resolve(file.localPath));
+            if (!file.source) {
+                debug('Skipping empty file.');
+                return;
+            }
+            await fs.mkdir(path.dirname(file.localPath), { recursive: true });
+            await fs.writeFile(file.localPath, file.source);
+        };
+        return await pMap(files, mapper);
+    }
+}
+function extractSyntaxError(error, files) {
+    var _a;
+    let message = error.message;
+    let snippet = '';
+    const re = /Syntax error: (.+) line: (\d+) file: (.+)/;
+    const [, errorName, lineNum, fileName] = (_a = re.exec(error.message)) !== null && _a !== void 0 ? _a : [];
+    if (fileName === undefined) {
+        return undefined;
+    }
+    message = `${errorName} - "${fileName}:${lineNum}"`;
+    // Get formatted code snippet
+    const contextCount = 4;
+    const errFile = files.find((x) => x.remotePath === fileName);
+    if (!errFile || !errFile.source) {
+        return undefined;
+    }
+    const srcLines = errFile.source.split('\n');
+    const errIndex = Math.max(parseInt(lineNum) - 1, 0);
+    const preIndex = Math.max(errIndex - contextCount, 0);
+    const postIndex = Math.min(errIndex + contextCount + 1, srcLines.length);
+    const preLines = chalk.dim(`  ${srcLines.slice(preIndex, errIndex).join('\n  ')}`);
+    const errLine = chalk.bold(`⇒ ${srcLines[errIndex]}`);
+    const postLines = chalk.dim(`  ${srcLines.slice(errIndex + 1, postIndex).join('\n  ')}`);
+    snippet = preLines + '\n' + errLine + '\n' + postLines;
+    return { message, snippet };
+}

package/build/src/core/functions.js

@@ -0,0 +1,51 @@
+import Debug from 'debug';
+import { google } from 'googleapis';
+import { assertAuthenticated, assertScriptConfigured, handleApiError } from './utils.js';
+const debug = Debug('clasp:core');
+export class Functions {
+    constructor(options) {
+        this.options = options;
+    }
+    async getFunctionNames() {
+        debug('Fetching runnable functions');
+        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 });
+        const res = await script.projects.getContent({ scriptId });
+        const files = res.data.files;
+        const functions = [];
+        if (!files) {
+            return functions;
+        }
+        return files.flatMap(file => { var _a, _b; return (_b = (_a = file.functionSet) === null || _a === void 0 ? void 0 : _a.values) !== null && _b !== void 0 ? _b : []; }).map(func => func.name);
+    }
+    async runFunction(functionName, parameters, devMode = true) {
+        debug('Running script function %s', functionName);
+        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 request = {
+                scriptId,
+                requestBody: {
+                    function: functionName,
+                    parameters: parameters !== null && parameters !== void 0 ? parameters : [],
+                    devMode,
+                },
+            };
+            debug('Running function with request: %O', request);
+            const res = await script.scripts.run(request);
+            if (!res.data) {
+                throw new Error('Function returned undefined');
+            }
+            return res.data;
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    }
+}

package/build/src/core/logs.js

@@ -0,0 +1,41 @@
+import Debug from 'debug';
+import { google } from 'googleapis';
+import { fetchWithPages } from './utils.js';
+import { assertAuthenticated, assertGcpProjectConfigured, handleApiError } from './utils.js';
+const debug = Debug('clasp:core');
+export class Logs {
+    constructor(options) {
+        this.options = options;
+    }
+    async getLogEntries(since) {
+        debug('Fetching logs');
+        assertAuthenticated(this.options);
+        assertGcpProjectConfigured(this.options);
+        const credentials = this.options.credentials;
+        const projectId = this.options.project.projectId;
+        const logger = google.logging({ version: 'v2', auth: credentials });
+        // Create a time filter (timestamp >= "2016-11-29T23:00:00Z")
+        // https://cloud.google.com/logging/docs/view/advanced-filters#search-by-time
+        const filter = since ? `timestamp >= "${since.toISOString()}"` : '';
+        try {
+            return fetchWithPages(async (pageSize, pageToken) => {
+                const res = await logger.entries.list({
+                    requestBody: {
+                        resourceNames: [`projects/${projectId}`],
+                        filter,
+                        orderBy: 'timestamp desc',
+                        pageSize,
+                        pageToken,
+                    },
+                });
+                return {
+                    results: res.data.entries || [],
+                    nextPageToken: res.data.nextPageToken,
+                };
+            });
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    }
+}

package/build/src/core/manifest.js

@@ -0,0 +1 @@
+export {};