corebasic 1.0.212 → 1.0.213

package/dist/libs/dip.js

@@ -0,0 +1,102 @@
+import * as Elabase from './elabase.js';
+export const start = Elabase.start;
+export const operation = Elabase.operation;
+export const insert = Elabase.insert;
+export const query = Elabase.query;
+export const update = Elabase.update;
+export const remove = Elabase.remove;
+export const newRaw = Elabase.newRaw;
+export const batchBegin = Elabase.batchBegin;
+export const batchAbort = Elabase.batchAbort;
+export const batchSubmit = Elabase.batchSubmit;
+export const batch = Elabase.batch;
+export const globalMeta = Elabase.globalMeta;
+export const companyMeta = Elabase.companyMeta;
+export const outletMeta = Elabase.outletMeta;
+export const customMeta = Elabase.customMeta;
+export const schema = Elabase.schema;
+export const isDipMeta = Elabase.isDipMeta;
+export const excludeCollectionConfig = Elabase.excludeCollectionConfig;
+export const includeCollectionConfig = Elabase.includeCollectionConfig;
+export const shard_stats = Elabase.shard_stats;
+export let config = Elabase.config;
+export async function insertSync(meta, feature, date, uid, ref, type) {
+    let stamp = new Date(date).toISOString();
+    let _id = `${meta.outlet}_${stamp}_${uid}`;
+    let data = { _id, ref, type: type === "REMOVE" ? type : "UPSERT" };
+    let collection = 'syncs.' + feature;
+    await Elabase.insert(meta, collection, data);
+}
+export const IdempotentDip = () => {
+    return {
+        txn: '',
+        meta: undefined,
+        new: (async function (meta, txn, blank) {
+            this.txn = txn;
+            this.meta = meta;
+            return blank ? this : ((await Elabase.query(this.meta, "txns", { _id: this.txn })).length ? false : this);
+        }),
+        insert: (async function (collection, query, data) {
+            await Elabase.update(this.meta, collection, query, { $setOnInsert: data }, { upsert: true });
+        }),
+        update: (async function (collection, query, data, rollback) {
+            let token = { [this.txn]: true };
+            let idempotent = { [this.txn]: { $exists: rollback ?? false } };
+            let result = await Elabase.update(this.meta, collection, { ...query, ...idempotent }, { ...data, $setOnInsert: undefined, $set: { ...(data.$set ?? {}), ...token } });
+            return result.count ? true : (await Elabase.query(this.meta, collection, { ...query, ...idempotent })).length;
+        }),
+        upsert: (async function (collection, query, data, rollback) {
+            await this.insert(collection, query, data.$setOnInsert);
+            return await this.update(collection, query, data, rollback);
+        }),
+        cleanup: (async function (collection, query) {
+            await Elabase.update(this.meta, collection, query, { $unset: { [this.txn]: true } });
+        }),
+        finish: (async function () {
+            return await Elabase.update(this.meta, "txns", { _id: this.txn }, {}, { upsert: true });
+        })
+    };
+};
+export const idip = async (message, callback, cleanup) => {
+    if (!callback)
+        throw new Error("Dip.idip() callback argument undefined");
+    if (!cleanup)
+        throw new Error("Dip.idip() cleanup argument undefined");
+    async function doCleanup(IDip) {
+        if (typeof cleanup === 'object') {
+            for (let collection in cleanup)
+                await IDip.cleanup(collection, { _id: { $in: cleanup[collection] } });
+        }
+        else
+            await cleanup(IDip);
+    }
+    let IDip = await IdempotentDip().new(message.meta, message.txn);
+    if (!IDip) {
+        IDip = await IdempotentDip().new(message.meta, message.txn, { blank: true });
+        await doCleanup(IDip);
+        return;
+    }
+    await callback(IDip);
+    await IDip.finish();
+    await doCleanup(IDip);
+};
+export const insertKeys = (message, meta) => {
+    if (!isDipMeta(meta))
+        throw new Error('Error: Provided meta is not an instance of DipMeta in Dip.insertKeys()');
+    return {
+        "created": message.date, "updated": message.date,
+        "createdBy": message.meta.staff,
+        "updatedBy": message.meta.staff,
+        "createdByUser": message.meta.user,
+        "updatedByUser": message.meta.user,
+        ...(meta?.company ? { "company": meta.company } : {}),
+        ...(meta?.outlet ? { "outlet": meta.outlet } : {}),
+    };
+};
+export const updateKeys = message => {
+    return {
+        "updated": message.date,
+        "updatedBy": message.meta.staff,
+        "updatedByUser": message.meta.user,
+    };
+};

package/dist/libs/dipper.js

@@ -0,0 +1,73 @@
+import axios from 'axios';
+// import {curly} from 'node-libcurl'
+function hashStr(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        let charCode = str.charCodeAt(i);
+        hash += charCode;
+    }
+    return hash;
+}
+function hash(string, digits) {
+    digits = digits || 6;
+    var m = Math.pow(10, digits + 1) - 1;
+    var phi = Math.pow(10, digits) / 2 - 1;
+    var n = 0;
+    for (var i = 0; i < string.length; i++) {
+        n = (n + phi * string.charCodeAt(i)) % m;
+    }
+    return n.toString();
+}
+let shards = [];
+let shardCount = 20;
+for (let i = 1; i <= shardCount; i++)
+    shards.push(`127.0.0.1:${9500 + i}`);
+// function shard(key) {
+//     return hash(key,1) % shardCount
+// }
+function shard(key) {
+    return hashStr(key) % shardCount;
+}
+export let shard_hits = {};
+async function postDip(url, arg) {
+    return (await axios.post(url, arg)).data;
+    // curl
+    // -----
+    //   const { data } = await curly.post(url, {
+    //   postFields: JSON.stringify(arg),
+    //   httpHeader: [
+    //     'Content-Type: application/json',
+    //     'Accept: application/json'
+    //     ],
+    //   })
+    //   return data
+}
+export default async function dipper(arg) {
+    let result = [];
+    let _id = arg.query?._id ?? arg.insert?._id ?? undefined;
+    if (!_id) {
+        let result = [];
+        for (let url of shards) {
+            shard_hits[url] = (shard_hits[url] ?? 0) + 1;
+            result.push(await postDip(`http://${url}/execute`, arg));
+        }
+    }
+    else {
+        let ids = typeof _id == "object" ? _id.$in : [_id];
+        for (let id of ids) {
+            let key = shard(id);
+            let url = shards[key];
+            shard_hits[url] = (shard_hits[url] ?? 0) + 1;
+            result.push(await postDip(`http://${url}/execute`, arg));
+        }
+    }
+    if (arg.mode === "query")
+        result = result.reduce((partial, item) => partial.concat(item), []);
+    return arg.mode === "query" ? result : result[0];
+}
+export const shard_stats = () => {
+    let total = Object.values(shard_hits).reduce((partial, value) => partial + value, 0);
+    let result = {};
+    Object.entries(shard_hits).forEach(([key, value]) => result[key] = parseFloat(value * 100 / total).toFixed(2));
+    return result;
+};