@foxtware/mineral 1.0.1 → 1.0.3

package/api/google/googlesheetsSpreadsheetSheetAdd.js

@@ -1,8 +1,11 @@
-const { ArgsWarden, objHasAny } = require('../utils');
+const { ArgsWarden, arrayToChunks, objHasAny } = require('../utils');
 const { credsValidator } = require('../validators');
 const { getGoogleSheets, googleApiCall } = require('../google/google.utils');
 const { googlesheetsSpreadsheetTrim } = require('../google/googlesheetsSpreadsheetTrim');
 
+// Sheets rejects oversized request bodies, so big exports go up in slices.
+const MAX_ROWS_PER_UPDATE = 5000;
+
 const spreadsheetIdentifierValidator = (spreadsheetIdentifier) => {
   return objHasAny(spreadsheetIdentifier, ['spreadsheetId']);
 };
@@ -81,6 +84,10 @@ const googlesheetsSpreadsheetSheetAdd = async (
           addSheet: {
             properties: {
               title: String(sheetName),
+              gridProperties: {
+                rowCount: values.length,
+                columnCount: headers.length,
+              },
             },
           },
         },
@@ -94,17 +101,23 @@ const googlesheetsSpreadsheetSheetAdd = async (
 
   const newSheetId = batchUpdateResponse.data.replies[0].addSheet.properties.sheetId;
 
-  const updateResponse = await googleApiCall(() => client.spreadsheets.values.update({
-    spreadsheetId,
-    range: `${ sheetName }!A1`,
-    valueInputOption: 'RAW',
-    requestBody: {
-      values,
-    },
-  }));
+  const chunks = arrayToChunks(values, MAX_ROWS_PER_UPDATE);
 
-  if (!updateResponse.ok) {
-    return updateResponse;
+  let updateResponse;
+
+  for (const [chunkIndex, chunk] of chunks.entries()) {
+    updateResponse = await googleApiCall(() => client.spreadsheets.values.update({
+      spreadsheetId,
+      range: `${ sheetName }!A${ (chunkIndex * MAX_ROWS_PER_UPDATE) + 1 }`,
+      valueInputOption: 'RAW',
+      requestBody: {
+        values: chunk,
+      },
+    }));
+
+    if (!updateResponse.ok) {
+      return updateResponse;
+    }
   }
 
   if (trim) {

package/api/google/googlesheetsSpreadsheetSheetDelete.js

@@ -0,0 +1,157 @@
+// https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#deletesheetrequest
+
+const { ArgsWarden, ensureArray, objHasAny } = require('../utils');
+const { credsValidator } = require('../validators');
+const { getGoogleSheets, googleApiCall } = require('../google/google.utils');
+
+const spreadsheetIdentifierValidator = (spreadsheetIdentifier) => {
+  return objHasAny(spreadsheetIdentifier, ['spreadsheetId']);
+};
+
+const sheetIdentifierValidator = (sheetIdentifier) => {
+  const sheetIdentifiers = ensureArray(sheetIdentifier);
+
+  return sheetIdentifiers.length > 0
+    && sheetIdentifiers.every((identifier) => {
+      return objHasAny(identifier, ['sheetName', 'sheetId']);
+    });
+};
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['spreadsheetIdentifier', spreadsheetIdentifierValidator],
+  ['sheetIdentifier', sheetIdentifierValidator],
+]);
+
+const googlesheetsSpreadsheetSheetDelete = async (
+  credsPayload,
+  spreadsheetIdentifier,
+  sheetIdentifier,
+  {
+    missingOk = true,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    spreadsheetIdentifier,
+    sheetIdentifier,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const { spreadsheetId } = spreadsheetIdentifier;
+  const sheetIdentifiers = ensureArray(sheetIdentifier);
+
+  const { client, error } = await getGoogleSheets(credsPayload);
+
+  if (error) {
+    return error;
+  }
+
+  const spreadsheetResponse = await googleApiCall(() => client.spreadsheets.get({
+    spreadsheetId,
+  }));
+
+  if (!spreadsheetResponse.ok) {
+    return spreadsheetResponse;
+  }
+
+  const sheetsArray = spreadsheetResponse.data?.sheets || [];
+
+  const resolved = [];
+  const missing = [];
+
+  for (const { sheetName, sheetId } of sheetIdentifiers) {
+    const sheet = sheetsArray.find(({ properties }) => {
+      return sheetId !== undefined
+        ? properties.sheetId === sheetId
+        : properties.title === sheetName;
+    });
+
+    if (!sheet) {
+      missing.push({ sheetName, sheetId });
+      continue;
+    }
+
+    resolved.push({
+      sheetId: sheet.properties.sheetId,
+      sheetName: sheet.properties.title,
+    });
+  }
+
+  if (missing.length && !missingOk) {
+    return {
+      ok: false,
+      error: {
+        code: 'SHEET_NOT_FOUND',
+        message: `Sheet not found: ${ JSON.stringify(missing) }`,
+      },
+    };
+  }
+
+  // Sheets refuses to remove the last remaining tab, so say so plainly rather
+  // than letting the API error surface without context.
+  if (resolved.length && resolved.length === sheetsArray.length) {
+    return {
+      ok: false,
+      error: {
+        code: 'CANNOT_DELETE_ALL_SHEETS',
+        message: 'A spreadsheet must keep at least one sheet',
+      },
+    };
+  }
+
+  if (!resolved.length) {
+    return {
+      ok: true,
+      data: {
+        deleted: [],
+        missing,
+      },
+    };
+  }
+
+  const batchUpdateResponse = await googleApiCall(() => client.spreadsheets.batchUpdate({
+    spreadsheetId,
+    requestBody: {
+      requests: resolved.map(({ sheetId }) => ({
+        deleteSheet: {
+          sheetId,
+        },
+      })),
+    },
+  }));
+
+  if (!batchUpdateResponse.ok) {
+    return batchUpdateResponse;
+  }
+
+  return {
+    ok: true,
+    data: {
+      deleted: resolved,
+      missing,
+    },
+  };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  googlesheetsSpreadsheetSheetDelete,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/googlesheetsSpreadsheetSheetDelete" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "google" },
+    "spreadsheetIdentifier": { "spreadsheetId": "ABC123" },
+    "sheetIdentifier": [{ "sheetName": "AU" }, { "sheetName": "US" }]
+  }'
+*/

package/api/google/googlesheetsSpreadsheetTrim.js

@@ -17,6 +17,8 @@ const googlesheetsSpreadsheetTrim = async (
   {
   } = {},
 ) => {
+  const { spreadsheetId } = spreadsheetIdentifier;
+
   const { client, error } = await getGoogleSheets(credsPayload);
 
   if (error) {

package/api/linear/linearOrganizationInviteCreate.js

@@ -0,0 +1,114 @@
+// https://linear.app/developers/graphql
+
+const { ArgsWarden, actionSingleOrMultiple, everyIfArray, valueProvided } = require('../utils');
+const { credsValidator } = require('../validators');
+const { linearClient } = require('../linear/linear.utils');
+
+const invitePayloadValidator = (invitePayload) => {
+  return valueProvided(invitePayload?.email);
+};
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['invitePayload', (invitePayload) => everyIfArray(invitePayloadValidator, invitePayload)],
+]);
+
+const linearOrganizationInviteCreateSingle = async (
+  credsPayload,
+  invitePayload,
+  {
+    inspect = false,
+    fetchClient = linearClient,
+  } = {},
+) => {
+  const {
+    email,
+    role = 'user',
+    teamIds,
+  } = invitePayload;
+
+  return fetchClient.fetch({
+    requestPayload: {
+      body: {
+        query: `
+          mutation OrganizationInviteCreate($input: OrganizationInviteCreateInput!) {
+            organizationInviteCreate(input: $input) {
+              success
+              organizationInvite {
+                id
+                email
+                role
+                createdAt
+                expiresAt
+                acceptedAt
+              }
+            }
+          }
+        `,
+        variables: {
+          input: {
+            email,
+            role,
+            ...teamIds && { teamIds },
+          },
+        },
+      },
+    },
+    context: {
+      credsPayload,
+      resultPath: 'data.organizationInviteCreate',
+    },
+    inspect,
+  });
+};
+
+const linearOrganizationInviteCreate = async (
+  credsPayload,
+  invitePayload,
+  {
+    inspect = false,
+    fetchClient = linearClient,
+    queueRunOptions,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    invitePayload,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return actionSingleOrMultiple(
+    invitePayload,
+    linearOrganizationInviteCreateSingle,
+    (invitePayloadItem) => ({
+      args: [credsPayload, invitePayloadItem, { inspect, fetchClient }],
+    }),
+    {
+      ...(queueRunOptions ? { queueRunOptions } : {}),
+    },
+  );
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  linearOrganizationInviteCreate,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/linearOrganizationInviteCreate" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "linear" },
+    "invitePayload": [
+      { "email": "someone@whitefoxboutique.com" },
+      { "email": "someoneelse@whitefoxboutique.com" }
+    ]
+  }'
+*/

package/api/workspace.js

@@ -32,6 +32,7 @@ const loadWorkspaceEnv = () => {
   dotenv.config({
     path: envFile,
     override: true,
+    quiet: true,
   });
 };
 

package/hosting/hosting.utils.js

@@ -16,6 +16,7 @@ const {
 
 dotenv.config({
   path: path.join(process.cwd(), '.env'),
+  quiet: true,
 });
 
 const MINERAL_WRAPPERS_MODULE = '@foxtware/mineral/hosting/wrappers.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxtware/mineral",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "bin": {
     "mineral": "bin/mineral.js"
   },