🍱 Add some examples

Author: Plopix

src/examples/dump-tenant.ts

@@ -0,0 +1,32 @@
+// Usage CRYSTALLIZE_ACCESS_TOKEN_ID=xxx CRYSTALLIZE_ACCESS_TOKEN_SECRET=xxx CRYSTALLIZE_TENANT_IDENTIFIER=xxx node dist/examples/dump-tenant.js
+
+import { CrystallizeClient } from '../';
+import { createDumper } from '../core/dump-tenant/dumper';
+import { createMassCallClient, CrystallizePromise, MassCallClientBatch } from '../core/massCallClient';
+import fs from 'fs';
+
+const onFailure = async (
+    batch: MassCallClientBatch,
+    exception: any,
+    promise: CrystallizePromise<any>,
+): Promise<boolean> => {
+    console.log(`Failure in batch from ${batch.from} to ${batch.to}: ${exception.message}`);
+    return true;
+};
+
+const client = createMassCallClient(CrystallizeClient, {
+    initialSpawn: 5000,
+    maxSpawn: 10000,
+    onFailure,
+});
+
+async function run() {
+    const dumper = createDumper(client, { tenantIdentifier: 'furniture' });
+    const spec = await dumper.dump();
+    try {
+        fs.writeFileSync('./plopnew.spec.json', JSON.stringify(spec));
+    } catch (err) {
+        console.error(err);
+    }
+}
+run();

src/examples/mass-async-call.ts

@@ -0,0 +1,69 @@
+// Usage: CRYSTALLIZE_TENANT_IDENTIFIER=furniture node dist/examples/massasynccall.js
+
+import { CrystallizeClient } from '..';
+import { createMassCallClient, CrystallizePromise, MassCallClientBatch } from '../core/massCallClient';
+
+// call of onBatchDone is not blocking. (no await done internally)
+const onBatchDone = async (batch: MassCallClientBatch): Promise<void> => {
+    console.log(`Batch from ${batch.from} to ${batch.to} Done!`);
+};
+
+// call of onFailure is blocking. (await is done internally)
+// Return:
+//     true: the failure is enqueued for retry (if called)
+//     false: the failure is not enqueued. You can retry it right away if you want.
+const onFailure = async (
+    batch: MassCallClientBatch,
+    exception: any,
+    promise: CrystallizePromise<any>,
+): Promise<boolean> => {
+    console.log(`Failure in batch from ${batch.from} to ${batch.to}`);
+    console.log([promise.query, promise.variables]);
+    //console.log(exception);
+    return true;
+};
+
+// call of beforeRequest is blocking. (await is done before each request is done)
+const beforeRequest = async (
+    batch: MassCallClientBatch,
+    promise: CrystallizePromise<any>,
+): Promise<CrystallizePromise<any> | void> => {
+    console.log(`Batch from ${batch.from} to ${batch.to} before request: ${promise.query}!`);
+};
+
+// call of afterRequest is blocking. (await is done after each request is finished)
+const afterRequest = async (
+    batch: MassCallClientBatch,
+    promise: CrystallizePromise<any>,
+    results: any,
+): Promise<void> => {
+    console.log(`Batch from ${batch.from} to ${batch.to} after request: ${promise.query}!`);
+    console.log(results);
+};
+
+const client = createMassCallClient(CrystallizeClient, {
+    initialSpawn: 1,
+    maxSpawn: 5,
+    onBatchDone,
+    onFailure,
+    beforeRequest,
+    afterRequest,
+});
+
+async function run() {
+    for (let i = 1; i <= 54; i++) {
+        client.enqueue.catalogueApi(`query { catalogue { id, key${i}: name } }`);
+    }
+
+    const success = await client.execute();
+    console.log('First pass done ', success);
+
+    console.log('Failed Count: ' + client.failureCount());
+    while (client.hasFailed()) {
+        console.log('Retrying ' + client.failureCount());
+        const newSuccess = await client.retry();
+        console.log('retry pass done ', newSuccess);
+    }
+    console.log('ALL DONE!');
+}
+run();