@google/clasp 2.4.2 → 3.0.0-alpha1

package/build/src/{apis.js → core/apis.js}

@@ -1,21 +1,6 @@
 /**
  * Google API Types
  */
-/**
- * Different types of starter script templates.
- * Technically, a script can be multiple types (e.g. Slides add-on/API),
- * but it's pretty rare that anyone wants that.
- */
-export var SCRIPT_TYPES;
-(function (SCRIPT_TYPES) {
-    SCRIPT_TYPES["STANDALONE"] = "standalone";
-    SCRIPT_TYPES["DOCS"] = "docs";
-    SCRIPT_TYPES["SHEETS"] = "sheets";
-    SCRIPT_TYPES["SLIDES"] = "slides";
-    SCRIPT_TYPES["FORMS"] = "forms";
-    SCRIPT_TYPES["WEBAPP"] = "webapp";
-    SCRIPT_TYPES["API"] = "api";
-})(SCRIPT_TYPES || (SCRIPT_TYPES = {}));
 /**
  * This is a list of all public Advanced Services.
  *
@@ -28,150 +13,163 @@ export var SCRIPT_TYPES;
  */
 export const PUBLIC_ADVANCED_SERVICES = [
     {
-        userSymbol: 'Classroom',
-        serviceId: 'classroom',
-        version: 'v1',
+        userSymbol: 'AdminDirectory',
+        version: 'directory_v1',
+        serviceId: 'admin',
     },
     {
-        userSymbol: 'Tasks',
-        serviceId: 'tasks',
+        userSymbol: 'AdminGroupsMigration',
         version: 'v1',
+        serviceId: 'groupsmigration',
     },
     {
-        userSymbol: 'BigQuery',
-        serviceId: 'bigquery',
-        version: 'v2',
-    },
-    {
-        userSymbol: 'DoubleClickCampaigns',
-        serviceId: 'dfareporting',
-        version: 'v3.3',
+        userSymbol: 'AdminGroupsSettings',
+        version: 'v1',
+        serviceId: 'groupssettings',
     },
     {
-        userSymbol: 'YouTube',
-        serviceId: 'youtube',
-        version: 'v3',
+        userSymbol: 'AdminLicenseManager',
+        version: 'v1',
+        serviceId: 'licensing',
     },
     {
-        userSymbol: 'FusionTables',
-        serviceId: 'fusiontables',
-        version: 'v2',
+        userSymbol: 'AdminReports',
+        version: 'reports_v1',
+        serviceId: 'admin',
     },
     {
-        userSymbol: 'Docs',
-        serviceId: 'docs',
+        userSymbol: 'AdminReseller',
         version: 'v1',
+        serviceId: 'reseller',
     },
     {
-        userSymbol: 'Drive',
-        serviceId: 'drive',
+        userSymbol: 'AdSense',
         version: 'v2',
+        serviceId: 'adsense',
     },
     {
-        userSymbol: 'AdminLicenseManager',
-        serviceId: 'licensing',
-        version: 'v1',
+        userSymbol: 'Analytics',
+        version: 'v3',
+        serviceId: 'analytics',
     },
     {
-        userSymbol: 'Mirror',
-        serviceId: 'mirror',
-        version: 'v1',
+        userSymbol: 'AnalyticsAdmin',
+        version: 'v1beta',
+        serviceId: 'analyticsadmin',
+    },
+    {
+        userSymbol: 'AnalyticsData',
+        version: 'v1beta',
+        serviceId: 'analyticsdata',
     },
     {
         userSymbol: 'AnalyticsReporting',
-        serviceId: 'analyticsreporting',
         version: 'v4',
+        serviceId: 'analyticsreporting',
     },
     {
-        userSymbol: 'AdminDirectory',
-        serviceId: 'admin',
-        version: 'directory_v1',
+        userSymbol: 'Area120Tables',
+        version: 'v1alpha1',
+        serviceId: 'area120tables',
     },
     {
-        userSymbol: 'AdminReports',
-        serviceId: 'admin',
-        version: 'reports_v1',
+        userSymbol: 'BigQuery',
+        version: 'v2',
+        serviceId: 'bigquery',
     },
     {
-        userSymbol: 'Gmail',
-        serviceId: 'gmail',
+        userSymbol: 'Calendar',
+        version: 'v3',
+        serviceId: 'calendar',
+    },
+    {
+        userSymbol: 'Chat',
         version: 'v1',
+        serviceId: 'chat',
     },
     {
-        userSymbol: 'AdSense',
-        serviceId: 'adsense',
-        version: 'v1.4',
+        userSymbol: 'Classroom',
+        version: 'v1',
+        serviceId: 'classroom',
     },
     {
-        userSymbol: 'TagManager',
-        serviceId: 'tagmanager',
+        userSymbol: 'Docs',
+        version: 'v1',
+        serviceId: 'docs',
+    },
+    {
+        userSymbol: 'DoubleClickCampaigns',
+        version: 'v4',
+        serviceId: 'dfareporting',
+    },
+    {
+        userSymbol: 'Drive',
+        version: 'v3',
+        serviceId: 'drive',
+    },
+    {
+        userSymbol: 'DriveActivity',
         version: 'v2',
+        serviceId: 'driveactivity',
     },
     {
-        userSymbol: 'AdminGroupsMigration',
-        serviceId: 'groupsmigration',
+        userSymbol: 'DriveLabels',
+        version: 'v2beta',
+        serviceId: 'drivelabels',
+    },
+    {
+        userSymbol: 'Gmail',
         version: 'v1',
+        serviceId: 'gmail',
     },
     {
-        userSymbol: 'Slides',
-        serviceId: 'slides',
+        userSymbol: 'People',
         version: 'v1',
+        serviceId: 'peopleapi',
     },
     {
         userSymbol: 'Sheets',
-        serviceId: 'sheets',
         version: 'v4',
+        serviceId: 'sheets',
     },
     {
         userSymbol: 'ShoppingContent',
+        version: 'v2.1',
         serviceId: 'content',
-        version: 'v2',
     },
     {
-        userSymbol: 'DriveActivity',
-        serviceId: 'driveactivity',
-        version: 'v2',
-    },
-    {
-        userSymbol: 'Calendar',
-        serviceId: 'calendar',
-        version: 'v3',
-    },
-    {
-        userSymbol: 'AdminReseller',
-        serviceId: 'reseller',
+        userSymbol: 'Slides',
         version: 'v1',
+        serviceId: 'slides',
     },
     {
-        userSymbol: 'YouTubeAnalytics',
-        serviceId: 'youtubeAnalytics',
+        userSymbol: 'TagManager',
         version: 'v2',
+        serviceId: 'tagmanager',
     },
     {
-        userSymbol: 'People',
-        serviceId: 'peopleapi',
+        userSymbol: 'Tasks',
         version: 'v1',
+        serviceId: 'tasks',
     },
     {
-        userSymbol: 'AppsActivity',
-        serviceId: 'appsactivity',
+        userSymbol: 'WorkspaceEvents',
         version: 'v1',
+        serviceId: 'workspaceevents',
     },
     {
-        userSymbol: 'YouTubeContentId',
-        serviceId: 'youtubePartner',
-        version: 'v1',
+        userSymbol: 'YouTube',
+        version: 'v3',
+        serviceId: 'youtube',
     },
     {
-        userSymbol: 'AdminGroupsSettings',
-        serviceId: 'groupssettings',
+        userSymbol: 'YouTubeAnalytics',
         version: 'v1',
+        serviceId: 'youtubeAnalytics',
     },
     {
-        userSymbol: 'Analytics',
-        serviceId: 'analytics',
-        version: 'v3',
+        userSymbol: 'YouTubeContentId',
+        version: 'v1',
+        serviceId: 'youtubePartner',
     },
 ];
-export const SCRIPT_ID_LENGTH = 57;
-//# sourceMappingURL=apis.js.map

package/build/src/core/clasp.js

@@ -0,0 +1,171 @@
+import path from 'path';
+import Debug from 'debug';
+import { findUpSync } from 'find-up';
+import fs from 'fs/promises';
+import splitLines from 'split-lines';
+import stripBom from 'strip-bom';
+import { Files } from './files.js';
+import { Functions } from './functions.js';
+import { Logs } from './logs.js';
+import { Project } from './project.js';
+import { Services } from './services.js';
+const debug = Debug('clasp:core');
+const DEFAULT_CLASP_IGNORE = [
+    '**/**',
+    '!**/appsscript.json',
+    '!**/*.gs',
+    '!**/*.js',
+    '!**/*.ts',
+    '!**/*.html',
+    '.git/**',
+    'node_modules/**',
+];
+export class Clasp {
+    constructor(options) {
+        debug('Creating clasp instance with options: %O', options);
+        this.options = options;
+        this.services = new Services(options);
+        this.files = new Files(options);
+        this.project = new Project(options);
+        this.logs = new Logs(options);
+        this.functions = new Functions(options);
+    }
+    withScriptId(scriptId) {
+        if (this.options.project) {
+            throw new Error('Science project already set, create new instance instead');
+        }
+        this.options.project = {
+            scriptId,
+        };
+        return this;
+    }
+    withContentDir(contentDir) {
+        if (!path.isAbsolute(contentDir)) {
+            contentDir = path.resolve(this.options.files.projectRootDir, contentDir);
+        }
+        this.options.files.contentDir = contentDir;
+        return this;
+    }
+}
+export async function initClaspInstance(options) {
+    debug('Initializing clasp instance');
+    const projectRoot = await findProjectRootdDir(options.configFile);
+    if (!projectRoot) {
+        debug('No project found, defaulting to cwd');
+        const rootDir = path.resolve(process.cwd());
+        const configFilePath = path.resolve(rootDir, '.clasp.json');
+        const ignoreFile = await findIgnoreFile(rootDir, options.ignoreFile);
+        const ignoreRules = await loadIgnoreFileOrDefaults(ignoreFile);
+        return new Clasp({
+            credentials: options.credentials,
+            configFilePath,
+            files: {
+                projectRootDir: rootDir,
+                contentDir: rootDir,
+                ignoreFilePath: ignoreFile,
+                ignorePatterns: ignoreRules,
+                filePushOrder: [],
+                fileExtension: 'js',
+            },
+        });
+    }
+    debug('Project config found at %s', projectRoot.configPath);
+    const ignoreFile = await findIgnoreFile(projectRoot.rootDir, options.ignoreFile);
+    const ignoreRules = await loadIgnoreFileOrDefaults(ignoreFile);
+    const content = await fs.readFile(projectRoot.configPath, { encoding: 'utf8' });
+    const config = JSON.parse(content);
+    const fileExtension = config.fileExtension || 'js';
+    const filePushOrder = config.filePushOrder || [];
+    const contentDir = path.resolve(projectRoot.rootDir, config.srcDir || config.rootDir || '.');
+    return new Clasp({
+        credentials: options.credentials,
+        configFilePath: projectRoot.configPath,
+        files: {
+            projectRootDir: projectRoot.rootDir,
+            contentDir: contentDir,
+            ignoreFilePath: ignoreFile,
+            ignorePatterns: ignoreRules,
+            filePushOrder: filePushOrder,
+            fileExtension: fileExtension,
+        },
+        project: {
+            scriptId: config.scriptId,
+            projectId: config.projectId,
+            parentId: config.parentId,
+        },
+    });
+}
+async function findProjectRootdDir(configFilePath) {
+    debug('Searching for project root');
+    if (configFilePath) {
+        debug('Checking for config file at %s', configFilePath);
+        const info = await fs.stat(configFilePath);
+        if (info.isDirectory()) {
+            debug('Is directory, trying file');
+            configFilePath = path.join(configFilePath, '.clasp.json');
+        }
+    }
+    else {
+        debug('Searching parent paths for .clasp.json');
+        configFilePath = findUpSync('.clasp.json');
+    }
+    if (!configFilePath) {
+        debug('No project found');
+        return undefined;
+    }
+    const configFileExists = await hasReadAccess(configFilePath);
+    if (!configFileExists) {
+        debug('Project file %s does not exist', configFilePath);
+        return undefined;
+    }
+    debug('Project found at %s', configFilePath);
+    const rootDir = path.dirname(configFilePath);
+    return {
+        rootDir,
+        configPath: configFilePath,
+    };
+}
+async function findIgnoreFile(projectDir, configFilePath) {
+    debug('Searching for ignore file');
+    if (configFilePath) {
+        debug('Checking for ignore file at %s', configFilePath);
+        const info = await fs.stat(configFilePath);
+        if (info.isDirectory()) {
+            debug('Is directory, trying file');
+            configFilePath = path.join(configFilePath, '.claspignore');
+        }
+    }
+    else {
+        debug('Checking default location');
+        configFilePath = path.join(projectDir, '.claspignore');
+    }
+    if (!configFilePath) {
+        debug('No ignore file found');
+        return undefined;
+    }
+    const configFileExists = await hasReadAccess(configFilePath);
+    if (!configFileExists) {
+        debug('ignore file %s does not exist', configFilePath);
+        return undefined;
+    }
+    debug('Ignore file found at %s', configFilePath);
+    return configFilePath;
+}
+async function loadIgnoreFileOrDefaults(configPath) {
+    if (!configPath) {
+        debug('Using default file ignore rules');
+        return DEFAULT_CLASP_IGNORE;
+    }
+    let content = await fs.readFile(configPath, { encoding: 'utf8' });
+    content = stripBom(content);
+    return splitLines(content).filter((name) => name.length > 0);
+}
+async function hasReadAccess(path) {
+    try {
+        await fs.access(path, fs.constants.R_OK);
+    }
+    catch {
+        return false;
+    }
+    return true;
+}