google-apis-cli 0.1.0 → 0.2.0

package/dist/src/config.js

@@ -1,89 +0,0 @@
-// Static config: OAuth client, the 13 scopes, and file paths.
-// Client id/secret follow the public-CLI pattern (gcloud/gh/firebase-tools):
-// embedded, overridable by env for the operator's own Desktop OAuth client.
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-// Embedded Desktop-client credentials (gcloud/gh/firebase-tools pattern),
-// overridable. Precedence: env → ~/.config/gapi/config.json (via `gapi auth
-// setup`) → embedded. Filled once the operator registers the OAuth Desktop
-// client (open item: credential not yet provisioned).
-const EMBEDDED_CLIENT_ID = '';
-const EMBEDDED_CLIENT_SECRET = '';
-// Resolved lazily (not at import) so it reads the config file after CONFIG_PATH
-// is initialized, and picks up a fresh `gapi auth setup` in the same process.
-export function getOAuthClient() {
-    const cfg = readConfigFile();
-    return {
-        clientId: process.env.GAPI_OAUTH_CLIENT_ID || String(cfg.oauth_client_id ?? '') || EMBEDDED_CLIENT_ID,
-        clientSecret: process.env.GAPI_OAUTH_CLIENT_SECRET ||
-            String(cfg.oauth_client_secret ?? '') ||
-            EMBEDDED_CLIENT_SECRET,
-    };
-}
-// Short name -> full scope URL. Manifest rows reference the short names;
-// the schema self-check asserts every row scope is a key here.
-const A = 'https://www.googleapis.com/auth/';
-export const SCOPES = {
-    adwords: `${A}adwords`,
-    'tagmanager.readonly': `${A}tagmanager.readonly`,
-    'tagmanager.edit.containers': `${A}tagmanager.edit.containers`,
-    'tagmanager.edit.containerversions': `${A}tagmanager.edit.containerversions`,
-    'tagmanager.publish': `${A}tagmanager.publish`,
-    'tagmanager.delete.containers': `${A}tagmanager.delete.containers`,
-    'tagmanager.manage.users': `${A}tagmanager.manage.users`,
-    'tagmanager.manage.accounts': `${A}tagmanager.manage.accounts`,
-    'analytics.readonly': `${A}analytics.readonly`,
-    'analytics.edit': `${A}analytics.edit`,
-    'analytics.manage.users': `${A}analytics.manage.users`,
-    webmasters: `${A}webmasters`,
-    indexing: `${A}indexing`,
-};
-export const ALL_SCOPE_URLS = Object.values(SCOPES);
-// Identity scopes (non-sensitive) so `auth status` can show the authenticated
-// account: the id_token then carries the email. Separate from the 13 API
-// scopes, which stay the coverage/self-check set.
-export const IDENTITY_SCOPES = ['openid', 'email'];
-export const CONSENT_SCOPES = [...ALL_SCOPE_URLS, ...IDENTITY_SCOPES];
-export const CONFIG_DIR = join(homedir(), '.config', 'gapi');
-export const CREDENTIALS_PATH = join(CONFIG_DIR, 'credentials.json');
-export const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
-// Read ~/.config/gapi/config.json (OAuth client id/secret, Ads login-customer-id,
-// quota project).
-export function readConfigFile() {
-    try {
-        return JSON.parse(readFileSync(CONFIG_PATH, 'utf8'));
-    }
-    catch {
-        return {};
-    }
-}
-// Write JSON under CONFIG_DIR readable only by the owner (dir 700, file 600).
-// Shared by the two things we persist: the config file and the credentials.
-export function writeSecureJson(path, data) {
-    mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
-    writeFileSync(path, JSON.stringify(data, null, 2), { mode: 0o600 });
-}
-// Precedence flag -> env -> config file. `flags` is the parsed argv values.
-// `cfg` defaults to the config file; injectable so precedence is unit-testable
-// without writing to ~/.config.
-export function resolveSetting(flags, { flag, env, key }, cfg = readConfigFile()) {
-    return flags?.[flag] ?? (env && process.env[env]) ?? cfg?.[key];
-}
-export const QUOTA_PROJECT_ENV = 'GOOGLE_CLOUD_PROJECT';
-// Google Ads sends login-customer-id (optional, MCC callers only) as an HTTP
-// header, not an OAuth scope, resolved flag -> env -> config file (header name
-// == flag == config key). developer-token was sunset 2026-09-09 (ignored by the
-// API; access is governed by the Cloud project), so it is not sent.
-const ADS_HEADERS = [
-    { name: 'login-customer-id', env: 'GOOGLE_ADS_LOGIN_CUSTOMER_ID' },
-];
-export function resolveAdsHeaders(flags, cfg = readConfigFile()) {
-    const out = {};
-    for (const { name, env } of ADS_HEADERS) {
-        const v = resolveSetting(flags, { flag: name, env, key: name }, cfg);
-        if (v != null)
-            out[name] = String(v);
-    }
-    return out;
-}

package/dist/src/manifest.js

@@ -1,69 +0,0 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-// Auto-discovery of API manifests. No central registry: a glob of
-// src/apis/*.js finds every surface, so a new API slice never edits a
-// shared file. Each manifest file default-exports:
-//   { api, baseUrl, resources: { <resource>: { <verb>: row } } }
-// row = { httpMethod, pathTemplate, scopes, requiredHeaders?, decoder?, listKey?, query? }
-import { readdirSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { SCOPES } from './config.js';
-const APIS_DIR = join(dirname(fileURLToPath(import.meta.url)), 'apis');
-export async function loadManifests(dir = APIS_DIR) {
-    // Match dev (.ts) and published (.js); skip declaration files.
-    const files = readdirSync(dir).filter((f) => (f.endsWith('.ts') || f.endsWith('.js')) && !f.endsWith('.d.ts'));
-    const manifests = {};
-    for (const f of files) {
-        const mod = await import(__rewriteRelativeImportExtension(join(dir, f)));
-        const m = mod.default;
-        manifests[m.api] = m;
-    }
-    return manifests;
-}
-// Flatten one manifest row and inject baseUrl so the executor is self-contained.
-export function findRow(manifests, api, resource, verb) {
-    const m = manifests[api];
-    const row = m?.resources?.[resource]?.[verb];
-    if (!row)
-        return null;
-    return { ...row, baseUrl: m.baseUrl };
-}
-const REQUIRED = ['httpMethod', 'pathTemplate', 'scopes'];
-// Schema self-check. Throws with all problems found. Substitutes N handler tests.
-export function checkSchema(manifests) {
-    const errors = [];
-    const known = new Set(Object.keys(SCOPES));
-    for (const [api, m] of Object.entries(manifests)) {
-        if (!m.baseUrl)
-            errors.push(`${api}: missing baseUrl`);
-        for (const [resource, verbs] of Object.entries(m.resources || {})) {
-            for (const [verb, row] of Object.entries(verbs)) {
-                const at = `${api}.${resource}.${verb}`;
-                for (const field of REQUIRED) {
-                    if (row[field] == null)
-                        errors.push(`${at}: missing ${field}`);
-                }
-                // pathTemplate placeholders must be simple {name} tokens (params supply them).
-                if (typeof row.pathTemplate === 'string') {
-                    const bad = row.pathTemplate.match(/\{[^}]*[^\w}][^}]*\}/g);
-                    if (bad)
-                        errors.push(`${at}: bad path placeholder ${bad.join(',')}`);
-                }
-                for (const s of row.scopes || []) {
-                    if (!known.has(s))
-                        errors.push(`${at}: unknown scope "${s}"`);
-                }
-            }
-        }
-    }
-    if (errors.length)
-        throw new Error(`manifest schema errors:\n${errors.join('\n')}`);
-    return true;
-}

package/dist/src/rest.js

@@ -1,90 +0,0 @@
-import { RestError } from './types.js';
-const RESERVED = new Set(['json', 'raw', 'limit', 'body']);
-// The {name} placeholders a pathTemplate declares. Shared with the dispatcher
-// so path params are extracted in exactly one place.
-export function pathParams(pathTemplate) {
-    return [...pathTemplate.matchAll(/\{(\w+)\}/g)].map((m) => m[1]);
-}
-// Fill {placeholders} in the path from params; return the used keys too.
-export function resolvePath(pathTemplate, params) {
-    const used = new Set();
-    const path = pathTemplate.replace(/\{(\w+)\}/g, (_, name) => {
-        if (params[name] == null)
-            throw new Error(`missing path param: ${name}`);
-        used.add(name);
-        return encodeURIComponent(String(params[name]));
-    });
-    return { path, used };
-}
-function buildUrl(baseUrl, pathTemplate, params) {
-    const { path, used } = resolvePath(pathTemplate, params);
-    const url = new URL(baseUrl + path);
-    // Leftover non-reserved params become query string, for every method: writes
-    // carry query params too (e.g. PATCH `updateMask`, list `pageSize`). The body
-    // is separate — RESERVED excludes it.
-    for (const [k, v] of Object.entries(params)) {
-        if (used.has(k) || RESERVED.has(k) || v == null)
-            continue;
-        url.searchParams.set(k, String(v));
-    }
-    return url;
-}
-// Merge a page's list array into acc under listKey. Returns the merged list.
-function mergeList(acc, page, listKey) {
-    const items = page?.[listKey];
-    if (Array.isArray(items))
-        return acc.concat(items);
-    return acc;
-}
-export async function execute(row, params, opts) {
-    const { tokenProvider, fetch: fetchImpl, quotaProject, extraHeaders = {} } = opts;
-    const method = row.httpMethod;
-    const headers = { Authorization: `Bearer ${await tokenProvider()}` };
-    if (quotaProject)
-        headers['x-goog-user-project'] = quotaProject;
-    for (const name of row.requiredHeaders || []) {
-        if (extraHeaders[name] == null)
-            throw new Error(`missing required header: ${name}`);
-    }
-    Object.assign(headers, extraHeaders);
-    const hasBody = method !== 'GET' && params.body != null;
-    if (hasBody)
-        headers['Content-Type'] = 'application/json';
-    const limit = params.limit != null ? Number(params.limit) : undefined;
-    let url = buildUrl(row.baseUrl, row.pathTemplate, params);
-    let last;
-    let merged = [];
-    let paged = false;
-    while (true) {
-        const res = await fetchImpl(url.toString(), {
-            method,
-            headers,
-            body: hasBody ? JSON.stringify(params.body) : undefined,
-        });
-        const text = await res.text();
-        const data = text ? JSON.parse(text) : {};
-        if (!res.ok) {
-            throw new RestError(data?.error?.message || `HTTP ${res.status}`, res.status, data);
-        }
-        last = data;
-        if (row.listKey) {
-            merged = mergeList(merged, data, row.listKey);
-            paged = true;
-            if (limit != null && merged.length >= limit) {
-                merged = merged.slice(0, limit);
-                break;
-            }
-            const next = data.nextPageToken;
-            if (!next)
-                break;
-            url = buildUrl(row.baseUrl, row.pathTemplate, { ...params, pageToken: next });
-            continue; // yagni: sequential paging; parallel prefetch if a surface ever needs it
-        }
-        break;
-    }
-    const raw = last;
-    let payload = paged ? { [row.listKey]: merged } : last;
-    if (row.decoder)
-        payload = row.decoder(paged ? merged : last, raw);
-    return { json: payload, raw };
-}