@shaxpir/duiduidui-models 1.0.0

package/dist/util/Logging.js

@@ -0,0 +1,412 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.ConsoleJsonLogRecorder = void 0;
+class ConsoleJsonLogRecorder {
+    recordLogEntry(item) {
+        const stringified = JSON.stringify(item);
+        if (item.level === 'error') {
+            console.error(stringified);
+        }
+        else if (item.level === 'warn') {
+            console.warn(stringified);
+        }
+        else {
+            console.log(stringified);
+        }
+    }
+}
+exports.ConsoleJsonLogRecorder = ConsoleJsonLogRecorder;
+class Logger {
+    constructor(recorder) {
+        this.fields = {};
+        this.recorder = recorder;
+    }
+    /* static method for creating a new Logger instance, optionally with a context */
+    static create(recorder, context) {
+        const b = new Logger(recorder);
+        if (context) {
+            b.withContext(context);
+        }
+        return b;
+    }
+    /* method for cloning a Logger instance */
+    clone() {
+        const clone = new Logger(this.recorder);
+        clone.withTimestamp(this.timestamp);
+        clone.withLevel(this.level);
+        clone.withMessage(this.message);
+        clone.withFields(this.fields);
+        return clone;
+    }
+    /* method for sending a log entry, which must be called in order to record the log item */
+    send() {
+        let timestamp = this.timestamp;
+        if (!timestamp) {
+            timestamp = new Date().toISOString();
+        }
+        this.recorder.recordLogEntry({
+            timestamp: timestamp,
+            level: this.level,
+            message: this.message,
+            fields: this.fields
+        });
+    }
+    /* method for setting a level and message */
+    info(message) {
+        this.withLevel('info');
+        this.withMessage(message);
+        return this;
+    }
+    warn(message) {
+        this.withLevel('warn');
+        this.withMessage(message);
+        return this;
+    }
+    debug(message) {
+        this.withLevel('debug');
+        this.withMessage(message);
+        return this;
+    }
+    error(message, err) {
+        this.withLevel('error');
+        this.withMessage(message);
+        this.withError(err);
+        return this;
+    }
+    /* methods for setting intrinsic LogItem properties */
+    withTimestamp(timestamp) {
+        if (timestamp instanceof Date) {
+            this.timestamp = timestamp.toISOString();
+        }
+        else {
+            this.timestamp = timestamp;
+        }
+        return this;
+    }
+    withLevel(level) {
+        this.level = level;
+        return this;
+    }
+    withMessage(message) {
+        this.message = message;
+        return this;
+    }
+    withFields(fields) {
+        // Iterate over all the new fields, and enforce the field types. Add them
+        // one-by-one using the withField method, which will enforce the field types.
+        let keys = Object.keys(fields);
+        for (let i = 0; i < keys.length; i++) {
+            let key = keys[i];
+            let value = fields[key];
+            this.withField(key, value);
+        }
+        return this;
+    }
+    withField(key, value) {
+        Logger.enforceFieldType(key, value);
+        if (value instanceof Date) {
+            value = value.toISOString();
+        }
+        this.fields[key] = value;
+        return this;
+    }
+    /* methods for setting specific fields, using appropriate types */
+    withServiceName(serviceName) {
+        this.withField('service_name', serviceName);
+        return this;
+    }
+    withNodeName(nodeName) {
+        this.withField('node_name', nodeName);
+        return this;
+    }
+    withVersion(version) {
+        this.withField('version', version);
+        return this;
+    }
+    withClientType(clientType) {
+        this.withField('client_type', clientType);
+        return this;
+    }
+    withClientServiceName(serviceName) {
+        this.withField('client_service_name', serviceName);
+        return this;
+    }
+    withClientNodeName(nodeName) {
+        this.withField('client_node_name', nodeName);
+        return this;
+    }
+    withClientVersion(version) {
+        this.withField('client_version', version);
+        return this;
+    }
+    withTopic(topic) {
+        this.withField('topic', topic);
+        return this;
+    }
+    withSubtopic(subtopic) {
+        this.withField('subtopic', subtopic);
+        return this;
+    }
+    withName(name) {
+        this.withField('name', name);
+        return this;
+    }
+    withContext(context) {
+        this.withField('context', context);
+        return this;
+    }
+    withUsingJwt(usingJwt) {
+        this.withField('using_jwt', usingJwt);
+        return this;
+    }
+    withUsingPassHash(usingPassHash) {
+        this.withField('using_pass_hash', usingPassHash);
+        return this;
+    }
+    withUserId(userId) {
+        this.withField('user_id', userId);
+        return this;
+    }
+    withEmail(email) {
+        this.withField('email', email);
+        return this;
+    }
+    withUrl(url) {
+        this.withField('url', url);
+        return this;
+    }
+    withSessionRef(sessionRef) {
+        this.withField('session_ref', sessionRef);
+        return this;
+    }
+    withContentKind(kind) {
+        this.withField('content_kind', kind);
+        return this;
+    }
+    withContentRef(ref) {
+        this.withField('content_ref', ref);
+        return this;
+    }
+    withCount(count) {
+        this.withField('count', count);
+        return this;
+    }
+    withDurationMillis(duration) {
+        this.withField('duration_millis', duration);
+        return this;
+    }
+    withDocVersion(version) {
+        this.withField('doc_version', version);
+        return this;
+    }
+    withWordCount(count) {
+        this.withField('word_count', count);
+        return this;
+    }
+    withBucket(bucket) {
+        this.withField('bucket', bucket);
+        return this;
+    }
+    withFileName(fileName) {
+        this.withField('file_name', fileName);
+        return this;
+    }
+    withFileSize(size) {
+        this.withField('file_size', size);
+        return this;
+    }
+    withRequestBody(body) {
+        this.withField('request_body', Logger.ensureStringified(body));
+        return this;
+    }
+    clearParams() {
+        delete this.fields.params;
+        return this;
+    }
+    withParams(params) {
+        // Layer in the new params over the old params, if they exist.
+        const oldParams = this.fields.params;
+        if (oldParams) {
+            let oldParamsObj;
+            try {
+                oldParamsObj = JSON.parse(oldParams);
+            }
+            catch (e) {
+                oldParamsObj = {};
+            }
+            this.fields.params = JSON.stringify({ ...oldParamsObj, ...params });
+        }
+        else {
+            this.fields.params = JSON.stringify(params);
+        }
+        return this;
+    }
+    withChangingData(originalData, transformedData) {
+        this.withOriginalData(originalData);
+        this.withTransformedData(transformedData);
+        return this;
+    }
+    withOriginalData(data) {
+        this.withField('original_data', Logger.ensureStringified(data));
+        return this;
+    }
+    withTransformedData(data) {
+        this.withField('transformed_data', Logger.ensureStringified(data));
+        return this;
+    }
+    withIgnoreConflict(ignoreConflict) {
+        this.withField('ignore_conflict', ignoreConflict);
+        return this;
+    }
+    withError(err) {
+        let stringified;
+        if (err != null && err != undefined) {
+            if (typeof err === 'string') {
+                stringified = err;
+            }
+            else if (err instanceof Error) {
+                // If this is a structured error object, it might have circular references, so handle that
+                // with the 'inspect' function. First, attempt to use a normal JSON.stringify() operation,
+                // and if that fails, (probably because of circular refs) then fall back to using 'inspect'.
+                try {
+                    stringified = JSON.stringify(err);
+                    if (stringified === '{}') {
+                        stringified = this.recorder.inspect(err);
+                    }
+                }
+                catch (e) {
+                    stringified = this.recorder.inspect(err);
+                }
+            }
+            else {
+                stringified = JSON.stringify(err);
+            }
+        }
+        if (stringified) {
+            this.withField('error_body', stringified);
+        }
+        return this;
+    }
+    static ensureStringified(value) {
+        if (typeof value === 'string') {
+            return value;
+        }
+        else {
+            return JSON.stringify(value);
+        }
+    }
+    static enforceFieldType(key, value) {
+        // Users can pass in Date values for fields that end with '_time' or '_date'. Those will be recorded
+        // as strings in the log entry, but we need to enforce that the field keys end with '_time' or '_date'.
+        // Likewise, if fields end with these suffixes, we need to enforce that the values either be strings
+        // that can be parsed as Dates, or actual Date objects (which will be stringified in the withField method).
+        if (value instanceof Date) {
+            if (key.endsWith('_time') || key.endsWith('_date')) {
+                return;
+            }
+            else {
+                throw new Error(`date field keys must end with '_time' or '_date': ${key}`);
+            }
+        }
+        else if (key.endsWith('_time') || key.endsWith('_date')) {
+            // Enforce that fields ending with '_time' or '_date' are strings or Dates.
+            if (typeof value == 'string') {
+                // Validate that the string value used for this field is parseable as a Date.
+                let date = new Date(value);
+                if (isNaN(date.getTime())) {
+                    throw new Error(`invalid date for log field '${key}': ${value}`);
+                }
+            }
+            else {
+                throw new Error(Logger.makeTypeErrorMessage(key, value, 'string'));
+            }
+            return;
+        }
+        if (key.endsWith('_name') || key.endsWith('_id')) {
+            // Enforce that fields ending with '_name' or '_id' are strings.
+            if (value != null && value != undefined && typeof value !== 'string') {
+                throw new Error(Logger.makeTypeErrorMessage(key, value, 'string'));
+            }
+            return;
+        }
+        if (key.endsWith('_count')) {
+            // Enforce that fields ending with '_count' are numbers.
+            if (value != null && value != undefined && typeof value !== 'number') {
+                throw new Error(Logger.makeTypeErrorMessage(key, value, 'number'));
+            }
+            return;
+        }
+        // We have to enforce field types, because the fields will be indexed in elasticsearch, and
+        // incorrect types will cause indexing errors. This is especially important for the well-known
+        // fields, but we also enforce it for all fields.
+        switch (key) {
+            case 'service_name':
+            case 'node_name':
+            case 'version':
+            case 'client_type':
+            case 'client_service_name':
+            case 'client_node_name':
+            case 'client_version':
+            case 'context':
+            case 'topic':
+            case 'subtopic':
+            case 'user_id':
+            case 'email':
+            case 'url':
+            case 'session_ref':
+            case 'content_kind':
+            case 'content_ref':
+            case 'bucket':
+            case 'name':
+            case 'file_name':
+            case 'request_body':
+            case 'original_data':
+            case 'transformed_data':
+            case 'error_body':
+                if (value != null && value != undefined && typeof value !== 'string') {
+                    throw new Error(Logger.makeTypeErrorMessage(key, value, 'string'));
+                }
+                return;
+            case 'params':
+                if (value != null && value != undefined) {
+                    if (typeof value == 'string') {
+                        // Validate that the string value used for this field is parseable as JSON.
+                        try {
+                            JSON.parse(value);
+                        }
+                        catch (e) {
+                            throw new Error(`invalid JSON for log field '${key}': ${value}`);
+                        }
+                    }
+                    else {
+                        throw new Error(Logger.makeTypeErrorMessage(key, value, 'string'));
+                    }
+                }
+                return;
+            case 'using_jwt':
+            case 'using_pass_hash':
+            case 'ignore_conflict':
+                if (value != null && value != undefined && typeof value !== 'boolean') {
+                    ;
+                    throw new Error(Logger.makeTypeErrorMessage(key, value, 'boolean'));
+                }
+                return;
+            case 'count':
+            case 'word_count':
+            case 'duration_millis':
+            case 'file_size':
+            case 'doc_version':
+                if (value != null && value != undefined && typeof value !== 'number') {
+                    throw new Error(Logger.makeTypeErrorMessage(key, value, 'number'));
+                }
+                return;
+        }
+        if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
+            throw new Error(`invalid type for log field '${key}': ${typeof value}`);
+        }
+    }
+    static makeTypeErrorMessage(key, value, expectedType) {
+        return `invalid type for log field '${key}': ${typeof value}; expected ${expectedType}`;
+    }
+}
+exports.Logger = Logger;

package/dist/util/NumberFormat.d.ts

@@ -0,0 +1,14 @@
+export declare class NumberFormat {
+    private static readonly ORDINAL_REGEX;
+    private static readonly NUMERIC_WORD_SEQUENCE;
+    private static readonly ROMAN_NUMERALS;
+    static commas(value: number, keepFractions: boolean): string;
+    static ordinal(value: number): string;
+    static isOrdinal(text: string): boolean;
+    static dollarsFromCents(value: number): string;
+    static percent(value: number, fractionDigits?: number): string;
+    static text(value: number): string;
+    static findNumericWordSequence(text: string): string;
+    static findRomanNumerals(text: string): string;
+    static asHex(value: number, padToLength?: number): string;
+}

package/dist/util/NumberFormat.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberFormat = void 0;
+class NumberFormat {
+    static commas(value, keepFractions) {
+        if (!Number.isFinite(value)) {
+            return "0"; //  We never want to show "NaN" or "Infinity" in shaxpir. Zero is always preferable.
+        }
+        let original = value;
+        let isNegative = value < 0;
+        let absValue = Math.abs(value);
+        let floorValue = Math.floor(absValue);
+        let v = floorValue;
+        let formatted = "";
+        if (v === 0) {
+            formatted = "0";
+        }
+        while (v > 0) {
+            if (formatted.length > 0) {
+                formatted = "," + formatted;
+            }
+            let remainder = (v % 1000);
+            v = Math.floor(v / 1000);
+            if (v > 0) {
+                if (remainder < 10) {
+                    formatted = "00" + remainder + formatted;
+                }
+                else if (remainder < 100) {
+                    formatted = "0" + remainder + formatted;
+                }
+                else {
+                    formatted = remainder + formatted;
+                }
+            }
+            else {
+                formatted = remainder + formatted;
+            }
+        }
+        if (keepFractions && absValue !== floorValue) {
+            formatted += "." + original.toString().split('.')[1];
+        }
+        if (isNegative) {
+            formatted = "-" + formatted;
+        }
+        return formatted;
+    }
+    static ordinal(value) {
+        if (value == 1 || (value % 10 == 1 && value != 11)) {
+            return "st";
+        }
+        else if (value == 2 || (value % 10 == 2 && value != 12)) {
+            return "nd";
+        }
+        else if (value == 3 || (value % 10 == 3 && value != 13)) {
+            return "rd";
+        }
+        else {
+            return "th";
+        }
+    }
+    static isOrdinal(text) {
+        return NumberFormat.ORDINAL_REGEX.test(text);
+    }
+    static dollarsFromCents(value) {
+        let dollars = Math.floor(value / 100);
+        let cents = value - (dollars * 100);
+        if (cents === 0) {
+            return "$" + dollars + ".00";
+        }
+        else if (cents < 10) {
+            return "$" + dollars + ".0" + cents;
+        }
+        else {
+            return "$" + dollars + "." + cents;
+        }
+    }
+    static percent(value, fractionDigits = 0) {
+        let numbers = NumberFormat.commas(value * 100, fractionDigits > 0);
+        if (fractionDigits > 0 && value !== 0) {
+            let indexOfDecimal = numbers.lastIndexOf(".");
+            if (indexOfDecimal >= 0) {
+                let numsBeforeDecimal = numbers.substring(0, indexOfDecimal);
+                let numsAfterDecimal = numbers.substring(indexOfDecimal + 1);
+                if (numsAfterDecimal.length > fractionDigits) {
+                    numbers = numsBeforeDecimal + "." + numsAfterDecimal.substring(0, fractionDigits);
+                }
+            }
+        }
+        return numbers + "%";
+    }
+    static text(value) {
+        let isNegative = value < 0;
+        value = Math.abs(Math.round(value));
+        let asText;
+        if (value == 0) {
+            asText = "zero";
+        }
+        else if (value == 1) {
+            asText = "one";
+        }
+        else if (value == 2) {
+            asText = "two";
+        }
+        else if (value == 3) {
+            asText = "three";
+        }
+        else if (value == 4) {
+            asText = "four";
+        }
+        else if (value == 5) {
+            asText = "five";
+        }
+        else if (value == 6) {
+            asText = "six";
+        }
+        else if (value == 7) {
+            asText = "seven";
+        }
+        else if (value == 8) {
+            asText = "eight";
+        }
+        else if (value == 9) {
+            asText = "nine";
+        }
+        else if (value == 10) {
+            asText = "ten";
+        }
+        else if (value == 11) {
+            asText = "eleven";
+        }
+        else if (value == 12) {
+            asText = "twelve";
+        }
+        else if (value == 13) {
+            asText = "thirteen";
+        }
+        else if (value == 14) {
+            asText = "fourteen";
+        }
+        else if (value == 15) {
+            asText = "fifteen";
+        }
+        else if (value == 16) {
+            asText = "sixteen";
+        }
+        else if (value == 17) {
+            asText = "seventeen";
+        }
+        else if (value == 18) {
+            asText = "eighteen";
+        }
+        else if (value == 19) {
+            asText = "nineteen";
+        }
+        else if (value >= 20 && value <= 99) {
+            let tensPlace = Math.floor(value / 10);
+            let onesPlace = value % 10;
+            if (tensPlace == 2) {
+                asText = "twenty";
+            }
+            else if (tensPlace == 3) {
+                asText = "thirty";
+            }
+            else if (tensPlace == 4) {
+                asText = "forty";
+            }
+            else if (tensPlace == 5) {
+                asText = "fifty";
+            }
+            else if (tensPlace == 6) {
+                asText = "sixty";
+            }
+            else if (tensPlace == 7) {
+                asText = "seventy";
+            }
+            else if (tensPlace == 8) {
+                asText = "eighty";
+            }
+            else if (tensPlace == 9) {
+                asText = "ninety";
+            }
+            if (onesPlace !== 0) {
+                asText += "-" + NumberFormat.text(onesPlace);
+            }
+        }
+        else if (value >= 100 && value <= 999) {
+            let hundredsPlace = Math.floor(value / 100);
+            asText = NumberFormat.text(hundredsPlace) + " hundred " + NumberFormat.text(value - (hundredsPlace * 100));
+        }
+        else if (value >= 1000 && value <= 9999) {
+            let thousandsPlace = Math.floor(value / 1000);
+            asText = NumberFormat.text(thousandsPlace) + " thousand " + NumberFormat.text(value - (thousandsPlace * 1000));
+        }
+        if (isNegative) {
+            asText = "minus " + asText;
+        }
+        return asText;
+    }
+    static findNumericWordSequence(text) {
+        let result = NumberFormat.NUMERIC_WORD_SEQUENCE.exec(text);
+        if (result !== null) {
+            return result[0];
+        }
+        return null;
+    }
+    static findRomanNumerals(text) {
+        let result = NumberFormat.ROMAN_NUMERALS.exec(text);
+        if (result !== null) {
+            return result[0];
+        }
+        return null;
+    }
+    static asHex(value, padToLength = 1) {
+        let hex = Math.floor(value).toString(16);
+        while (hex.length < padToLength) {
+            hex = "0" + hex;
+        }
+        return hex;
+    }
+}
+exports.NumberFormat = NumberFormat;
+NumberFormat.ORDINAL_REGEX = /^\d*(?:1st|2nd|3rd|[04-9]th|1[23]th)$/i;
+NumberFormat.NUMERIC_WORD_SEQUENCE = /(?:one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|(?:thir|four|fif|six|seven|eigh|nine)teen|(?:twen|thir|for|fif|six|seven|eigh|nine)ty|[mb]illion|thousand|hundred)(?:(?:\s*(?:\sand\s+|-\s*)(?:one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|(?:thir|four|fif|six|seven|eigh|nine)teen|(?:twen|thir|for|fif|six|seven|eigh|nine)ty|[mb]illion|thousand|hundred)))*/i;
+NumberFormat.ROMAN_NUMERALS = /\b[MDCLXVI]+\b/i;

package/dist/util/Struct.d.ts

@@ -0,0 +1,4 @@
+export declare class Struct {
+    static clone(value: any): any;
+    static equals(a: any, b: any): boolean;
+}

package/dist/util/Struct.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Struct = void 0;
+const rfdc = require("rfdc");
+const isEqual = require("fast-deep-equal");
+const cloneDeep = rfdc();
+class Struct {
+    static clone(value) {
+        return cloneDeep(value);
+    }
+    static equals(a, b) {
+        return isEqual(a, b);
+    }
+}
+exports.Struct = Struct;

package/dist/util/Template.d.ts

@@ -0,0 +1,16 @@
+export declare class TemplateParser {
+    private static TAG_PATTERN;
+    static parse(text: string): Template;
+    private static fromChunks;
+    private static findEndIndex;
+}
+export interface Renderable {
+    render: (params: any) => string;
+}
+export declare class Template implements Renderable {
+    private parts;
+    private name;
+    private negated;
+    constructor(parts: Renderable[], name: string, negated: boolean);
+    render(params: any): string;
+}