@trycourier/cli 2.4.0 → 2.5.0

package/dist/commands/UsersTokensBulk.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const _default: () => React.JSX.Element;
+export default _default;

package/dist/commands/UsersTokensBulk.js

@@ -0,0 +1,215 @@
+import { ProgressBar } from '@inkjs/ui';
+import { Box, Text } from 'ink';
+import _ from 'lodash';
+import fs from 'fs/promises';
+import React, { useEffect, useState } from 'react';
+import { useBoolean, useCounter } from 'usehooks-ts';
+import getDb, { getChunk } from '../bulk.js';
+import { useCliContext } from '../components/Context.js';
+import Spinner from '../components/Spinner.js';
+import UhOh from '../components/UhOh.js';
+import delay from '../lib/delay.js';
+const DEFAULT_DELAY = 5000;
+const DEFAULT_CHUNK_SIZE = 500;
+const DEFAULT_TIMEOUT = 10;
+const DEFAULT_ERROR_FILENAME = 'errors.json';
+export default () => {
+    const { parsedParams, courier } = useCliContext();
+    const [error, setError] = useState();
+    const processing = useBoolean(true);
+    const running = useBoolean(true);
+    const [data, setData] = useState();
+    const [data_errors, setDataErrors] = useState([]);
+    const counter = useCounter(0);
+    const [row_errors, setRowErrors] = useState([]);
+    const filename = String(_.get(parsedParams, ['_', 0], ''));
+    const { db, filetype, sql } = getDb(filename);
+    const delay_between_chunks = Number(parsedParams['delay']) ?? DEFAULT_DELAY;
+    const chunk_size = parsedParams['chunk_size']
+        ? Number(parsedParams['chunk_size'])
+        : DEFAULT_CHUNK_SIZE;
+    const log_errors = true;
+    useEffect(() => {
+        if (filetype) {
+            getData();
+        }
+        else {
+            setError('File type not supported.');
+        }
+    }, []);
+    useEffect(() => {
+        if (data) {
+            processData();
+        }
+    }, [data]);
+    useEffect(() => {
+        if (!processing.value) {
+            handleErrors();
+        }
+    }, [processing.value]);
+    const getData = () => {
+        db.all(sql, (err, result) => {
+            if (err) {
+                setError(err.message);
+            }
+            else {
+                setData(result);
+            }
+        });
+    };
+    const processChunkRows = (data, start_index) => {
+        return data.map((row, i) => {
+            const curr_index = start_index + i;
+            let { user_id, token, provider_key, device, tracking, expiry_date, ...properties } = row || {};
+            if (!device)
+                device = {};
+            if (!tracking)
+                tracking = {};
+            if (!properties)
+                properties = {};
+            if (!user_id) {
+                return Promise.resolve({
+                    success: false,
+                    userId: '__unknown__',
+                    error: `user_id not found in index ${curr_index}`,
+                    index: curr_index,
+                });
+            }
+            else if (!provider_key) {
+                return Promise.resolve({
+                    success: false,
+                    userId: user_id,
+                    error: `provider_key not found in index ${curr_index}`,
+                    index: curr_index,
+                });
+            }
+            else if (!token) {
+                return Promise.resolve({
+                    success: false,
+                    userId: user_id,
+                    error: `token not found in index ${curr_index}`,
+                    index: curr_index,
+                });
+            }
+            else {
+                Object.entries(properties).forEach(([key, value]) => {
+                    if (key.startsWith('device.')) {
+                        _.unset(properties, key);
+                        _.set(device, key.replace('device.', ''), value);
+                    }
+                    else if (key.startsWith('tracking.')) {
+                        _.unset(properties, key);
+                        _.set(tracking, key.replace('tracking.', ''), value);
+                    }
+                    else {
+                        _.unset(properties, key);
+                        _.set(properties, key.replace('properties.', ''), value);
+                    }
+                });
+                return processRow({
+                    user_id: String(user_id),
+                    token: token,
+                    provider_key,
+                    device,
+                    tracking,
+                    expiry_date,
+                    properties,
+                    index: curr_index,
+                });
+            }
+        });
+    };
+    const processRow = async ({ user_id, token, index, ...body }) => {
+        return new Promise(async (resolve) => {
+            let promises = [];
+            try {
+                promises.push(courier.users.tokens.add(user_id, token, body, {
+                    maxRetries: 5,
+                    timeoutInSeconds: DEFAULT_TIMEOUT,
+                }));
+                await Promise.all(promises);
+                counter.increment();
+                return resolve({ userId: user_id, success: true, index });
+            }
+            catch (error) {
+                counter.increment();
+                return resolve({
+                    userId: user_id,
+                    success: false,
+                    index,
+                    error: (String(error) ??
+                        error?.message ??
+                        error.message ??
+                        'Unknown Error') + `+ ${user_id}`,
+                });
+            }
+        });
+    };
+    const processData = async () => {
+        if (data?.length) {
+            let data_copy = [...data];
+            let counter = 0;
+            let { rows, data: rest } = getChunk(data_copy, chunk_size);
+            while (rows?.length) {
+                const chunk = processChunkRows(rows, counter);
+                const processed_chunks = await Promise.all(chunk);
+                const errors = processed_chunks.filter(r => !r.success);
+                if (errors.length) {
+                    setDataErrors(p => [
+                        ...p,
+                        ...errors.map(r => {
+                            return `user_id (${r.userId}) failed to update in index ${r.index}: ${String(r.error)}`;
+                        }),
+                    ]);
+                    setRowErrors(r => [
+                        ...r,
+                        ...errors.map(e => data[e.index]),
+                    ]);
+                }
+                if (rest.length > 0) {
+                    await delay(delay_between_chunks);
+                    counter += rows.length;
+                    const next = getChunk(rest, chunk_size);
+                    rows = next.rows;
+                    rest = next.data;
+                }
+                else {
+                    processing.setFalse();
+                    break;
+                }
+            }
+        }
+    };
+    const handleErrors = async () => {
+        if (row_errors.length && log_errors) {
+            await fs.writeFile(DEFAULT_ERROR_FILENAME, JSON.stringify(row_errors, null, 2), {
+                encoding: 'utf-8',
+            });
+            running.setFalse();
+        }
+        else {
+            running.setFalse();
+        }
+    };
+    if (!filename?.length) {
+        return React.createElement(UhOh, { text: "You must specify a filename." });
+    }
+    else if (error?.length) {
+        return React.createElement(UhOh, { text: error });
+    }
+    else if (data && running.value) {
+        return (React.createElement(React.Fragment, null,
+            React.createElement(ProgressBar, { value: Math.floor((counter.count / data.length) * 100) }),
+            React.createElement(Spinner, { text: `Completed Rows: ${counter.count} / ${data.length}` })));
+    }
+    else {
+        return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+            React.createElement(Text, { color: 'green' }, `Completed Rows: ${counter.count} / ${data?.length || 0}`),
+            data_errors.map((err, i) => {
+                return React.createElement(UhOh, { key: i, text: err });
+            }),
+            log_errors && data_errors.length ? (React.createElement(Text, null,
+                "Errors output to ",
+                DEFAULT_ERROR_FILENAME)) : (React.createElement(React.Fragment, null))));
+    }
+};

package/dist/mappings.js

@@ -21,6 +21,7 @@ import AutomationInvokeBulk from './commands/AutomationInvokeBulk.js';
 import MessagesSearch from './commands/MessagesSearch.js';
 import TenantsMembershipBulk from './commands/TenantsMembershipBulk.js';
 import AudienceSearch from './commands/AudienceSearch.js';
+import UsersTokensBulk from './commands/UsersTokensBulk.js';
 const mappings = new Map();
 export const COMMON_OPTIONS = [
     {
@@ -281,6 +282,18 @@ mappings.set('users:bulk', {
     ],
     component: () => React.createElement(UsersBulk, null),
 });
+mappings.set('users:tokens:bulk', {
+    params: '<filename>',
+    instructions: 'Bulk import user tokens from a file (csv, json, jsonl, xls, xlsx, .parquet)." For CSVs, we will unpack nested objects into  based on the header. E.g., "address.city" becomes {"address": {"city": "value"}}. Lodash path syntax is used for created the nested object. Supports wildcard syntax for multiple files, must surround with quotes (see examples).',
+    options: [
+        {
+            option: '--replace',
+            value: 'Replace existing users with the same ID, if not set, will do a merge based on key',
+        },
+    ],
+    example: ['courier users:tokens:bulk examples/users-tokens.csv'],
+    component: () => React.createElement(UsersTokensBulk, null),
+});
 mappings.set('users:preferences', {
     params: '<user>',
     instructions: 'Fetch the preferences for a given user ID',

package/dist/version.js

@@ -1,2 +1,2 @@
-let VERSION = '2.4.0';
+let VERSION = '2.5.0';
 export default VERSION;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@trycourier/cli",
-	"version": "2.4.0",
+	"version": "2.5.0",
 	"license": "MIT",
 	"bin": {
 		"courier": "dist/cli.js"