sheetspeare/dist/core/sheets.js

Import locales from Google Sheet into Json files.

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { GoogleSpreadsheet } from 'google-spreadsheet';
import { JWT } from 'google-auth-library';
import { ConfigSheetName, LocaleSheetName } from '../constants.js';
import { parseLocaleKey } from '../utils/json.js';
import { logger } from '../utils/logger.js';
export const loadSpreadsheet = (options) => __awaiter(void 0, void 0, void 0, function* () {
    try {
        const spreadsheet = new GoogleSpreadsheet(options.spreadsheetId, new JWT({
            email: options.serviceAccountEmail,
            key: options.serviceAccountPrivateKey,
            scopes: ['https://www.googleapis.com/auth/spreadsheets', 'https://www.googleapis.com/auth/drive.file'],
        }));
        yield spreadsheet.loadInfo();
        return { data: spreadsheet, error: null };
    }
    catch (error) {
        return { data: null, error: error };
    }
});
export const initializeSpreadsheet = (options) => __awaiter(void 0, void 0, void 0, function* () {
    try {
        const sheet = options.spreadsheet.sheetsByIndex[0];
        yield sheet.updateProperties({ title: LocaleSheetName });
        yield sheet.setHeaderRow(['key', ...options.locales], 0);
        yield sheet.resize({ columnCount: options.locales.length + 1, rowCount: 1 });
        const configSheet = yield options.spreadsheet.addSheet({ title: ConfigSheetName, index: 1 });
        yield configSheet.setHeaderRow(['key', 'value', 'description']);
        yield configSheet.resize({ columnCount: 3, rowCount: 1 });
        yield configSheet.addRows([
            {
                key: 'snapshotCount',
                value: 3,
                description: '(Number) Number of snapshot sheets. Set to 0 to disable creating a snapshot on each push',
            },
        ]);
        return { data: undefined, error: null };
    }
    catch (error) {
        return { data: null, error: error };
    }
});
export const getLocalesSheet = (spreadsheet) => {
    const sheet = spreadsheet.sheetsByTitle[LocaleSheetName];
    if (!sheet) {
        return { data: null, error: new Error(`Sheet ${LocaleSheetName} not found`) };
    }
    return { data: sheet, error: null };
};
export const getConfigSheet = (spreadsheet) => {
    const sheet = spreadsheet.sheetsByTitle[ConfigSheetName];
    if (!sheet) {
        return { data: null, error: new Error(`Sheet "${ConfigSheetName}" not found`) };
    }
    return { data: sheet, error: null };
};
export const getSpreadsheetConfig = (spreadsheet) => __awaiter(void 0, void 0, void 0, function* () {
    const { data: sheet, error: configSheetError } = getConfigSheet(spreadsheet);
    if (configSheetError) {
        return { data: null, error: configSheetError };
    }
    const rows = yield sheet.getRows();
    const config = {};
    rows.forEach((row) => {
        const key = row.get('key');
        const value = row.get('value');
        switch (key) {
            case 'snapshotCount':
                config.snapshotCount = Number(value);
                break;
            default:
                break;
        }
    });
    return { data: config, error: null };
});
export const snapshot = (options) => __awaiter(void 0, void 0, void 0, function* () {
    const { data: spreadsheetConfig } = yield getSpreadsheetConfig(options.spreadsheet);
    const limit = (spreadsheetConfig === null || spreadsheetConfig === void 0 ? void 0 : spreadsheetConfig.snapshotCount) || 0;
    if (!limit) {
        return { data: undefined, error: null };
    }
    const { data: sheet, error: localSheetError } = getLocalesSheet(options.spreadsheet);
    if (localSheetError) {
        return { data: null, error: localSheetError };
    }
    try {
        const oldSnapshots = options.spreadsheet.sheetsByIndex
            .filter((sheet) => sheet.title.startsWith('Snapshot'))
            .sort((a, b) => {
            const aDate = new Date(a.title.replace('Snapshot ', ''));
            const bDate = new Date(b.title.replace('Snapshot ', ''));
            return bDate.getTime() - aDate.getTime();
        });
        yield sheet.duplicate({ title: `Snapshot ${new Date().toISOString()}`, index: 2 });
        Promise.all(oldSnapshots.map((snapshot, index) => __awaiter(void 0, void 0, void 0, function* () {
            if (index + 1 >= limit) {
                yield snapshot.delete();
            }
        })));
        return { data: undefined, error: null };
    }
    catch (error) {
        return { data: null, error: error };
    }
});
export const updateSpreadsheetLocales = (options) => __awaiter(void 0, void 0, void 0, function* () {
    const { data: sheet, error: localesSheetError } = getLocalesSheet(options.spreadsheet);
    if (localesSheetError) {
        return { data: null, error: localesSheetError };
    }
    const rows = yield sheet.getRows();
    const changedRows = new Map();
    const addedRows = new Map();
    // Create a new snapshot
    if (rows.length) {
        yield snapshot({ spreadsheet: options.spreadsheet });
    }
    // Update existing locales
    yield Promise.all(Object.entries(options.localizationDiff.updated).map(([localeWithKey, value]) => __awaiter(void 0, void 0, void 0, function* () {
        const [locale, key] = parseLocaleKey(localeWithKey);
        const row = rows.find((row) => row.get('key') === key);
        if (row) {
            row.set(locale, value);
            changedRows.set(key, row);
        }
    })));
    // Add new locales
    yield Promise.all(Object.entries(options.localizationDiff.added).map(([localeWithKey, value]) => __awaiter(void 0, void 0, void 0, function* () {
        const [locale, key] = parseLocaleKey(localeWithKey);
        const row = rows.find((row) => row.get('key') === key);
        if (!row) {
            const rowToAdd = addedRows.get(key) || { key };
            addedRows.set(key, Object.assign(Object.assign({}, rowToAdd), { [locale]: value }));
        }
        else {
            row.set(locale, value);
            changedRows.set(key, row);
        }
    })));
    // Remove deleted locales
    if (options.deleteMissingLocales && Object.keys(options.localizationDiff.deleted).length) {
        yield Promise.all(Object.entries(options.localizationDiff.deleted).map(([localeWithKey]) => __awaiter(void 0, void 0, void 0, function* () {
            const [locale, key] = parseLocaleKey(localeWithKey);
            const row = rows.find((row) => row.get('key') === key);
            if (row) {
                row.set(locale, '');
                changedRows.set(key, row);
            }
        })));
        logger.warn('Deleted locales cells were removed from the spreadsheet, Please clean empty rows manually.');
    }
    yield Promise.all([...changedRows.values()].map((row) => __awaiter(void 0, void 0, void 0, function* () { return row.save(); })));
    const addedRowsArray = [...addedRows.values()];
    if (addedRowsArray.length) {
        yield sheet.addRows([...addedRows.values()]);
    }
    return { data: undefined, error: null };
});