@shaxpir/duiduidui-models 1.3.1 → 1.3.3

package/lib/util/Logging.ts

@@ -1,568 +0,0 @@
-export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
-
-export type ClientType = 'user' | 'server' | 'desktop' | 'browser';
-
-export interface LogItem {
-  timestamp: string;
-  level: LogLevel;
-  message: string;
-  fields: LogFields;
-}
-
-// The LogRecorder interface is used to define the interface for the transport mechanism that
-// actually records the log entries somewhere. It must provice a recordLogEntry method that takes
-// a LogItem object as an argument, and it must provide an inspect method that takes an error object
-// as an argument and returns a string representation of the error. This allows the Logger class to
-// record log entries without knowing the details of how they are recorded. And the 'inspect' method
-// will have a different implementation in the browser than in node.js.
-export interface LogRecorder {
-  recordLogEntry(item: LogItem): void;
-  inspect(err:any):string;
-}
-
-export abstract class ConsoleJsonLogRecorder implements LogRecorder {
-  abstract inspect(err: any): string;
-  public recordLogEntry(item: LogItem): void {
-    const stringified = JSON.stringify(item);
-    if (item.level === 'error') {
-      console.error(stringified);
-    } else if (item.level === 'warn') {
-      console.warn(stringified);
-    } else {
-      console.log(stringified);
-    }
-  }
-}
-
-export class Logger {
-
-  private recorder:LogRecorder;
-
-  private timestamp:string;
-  private level:LogLevel;
-  private message:string;
-  private fields:LogFields = {};
-
-  constructor(recorder:LogRecorder) {
-    this.recorder = recorder;
-  }
-
-  /* static method for creating a new Logger instance, optionally with a context */
-
-  public static create(
-    recorder:LogRecorder,
-    context?:string,
-  ):Logger {
-    const b = new Logger(recorder);
-    if (context) {
-      b.withContext(context);
-    }
-    return b;
-  }
-
-  /* method for cloning a Logger instance */
-
-  public clone():Logger {
-    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 */
-
-  public send():void {
-    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 */
-
-  public info(message:string):Logger {
-    this.withLevel('info');
-    this.withMessage(message);
-    return this;
-  }
-
-  public warn(message:string):Logger {
-    this.withLevel('warn');
-    this.withMessage(message);
-    return this;
-  }
-
-  public debug(message:string):Logger {
-    this.withLevel('debug');
-    this.withMessage(message);
-    return this;
-  }
-
-  public error(message:string, err?:any):Logger {
-    this.withLevel('error');
-    this.withMessage(message);
-    this.withError(err);
-    return this;
-  }
-
-  /* methods for setting intrinsic LogItem properties */
-
-  public withTimestamp(timestamp:Date|string):Logger {
-    if (timestamp instanceof Date) {
-      this.timestamp = timestamp.toISOString();
-    } else {
-      this.timestamp = timestamp;
-    }
-    return this;
-  }
-
-  public withLevel(level:LogLevel):Logger {
-    this.level = level;
-    return this;
-  }
-
-  public withMessage(message:string):Logger {
-    this.message = message;
-    return this;
-  }
-
-  public withFields(fields:LogFields):Logger {
-    // 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;
-  }
-
-  public withField(key:string, value:string | number | boolean | Date):Logger {
-    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 */
-
-
-  public withServiceName(serviceName:string):Logger {
-    this.withField('service_name', serviceName);
-    return this;
-  }
-
-  public withNodeName(nodeName:string):Logger {
-    this.withField('node_name', nodeName);
-    return this;
-  }
-
-  public withVersion(version:string):Logger {
-    this.withField('version', version);
-    return this;
-  }
-
-  public withClientType(clientType:ClientType):Logger {
-    this.withField('client_type', clientType);
-    return this;
-  }
-
-  public withClientServiceName(serviceName:string):Logger {
-    this.withField('client_service_name', serviceName);
-    return this;
-  }
-
-  public withClientNodeName(nodeName:string):Logger {
-    this.withField('client_node_name', nodeName);
-    return this;
-  }
-
-  public withClientVersion(version:string):Logger {
-    this.withField('client_version', version);
-    return this;
-  }
-
-  public withTopic(topic:string):Logger {
-    this.withField('topic', topic);
-    return this;
-  }
-
-  public withSubtopic(subtopic:string):Logger {
-    this.withField('subtopic', subtopic);
-    return this;
-  }
-
-  public withName(name:string):Logger {
-    this.withField('name', name);
-    return this;
-  }
-
-  public withContext(context:string):Logger {
-    this.withField('context', context);
-    return this;
-  }
-
-  public withUsingJwt(usingJwt:boolean):Logger {
-    this.withField('using_jwt', usingJwt);
-    return this;
-  }
-
-  public withUsingPassHash(usingPassHash:boolean):Logger {
-    this.withField('using_pass_hash', usingPassHash);
-    return this;
-  }
-
-  public withUserId(userId:string):Logger {
-    this.withField('user_id', userId);
-    return this;
-  }
-
-  public withEmail(email:string):Logger {
-    this.withField('email', email);
-    return this;
-  }
-
-  public withUrl(url:string):Logger {
-    this.withField('url', url);
-    return this;
-  }
-
-  public withSessionRef(sessionRef:string):Logger {
-    this.withField('session_ref', sessionRef);
-    return this;
-  }
-
-  public withContentKind(kind:string):Logger {
-    this.withField('content_kind', kind);
-    return this;
-  }
-
-  public withContentRef(ref:string):Logger {
-    this.withField('content_ref', ref);
-    return this;
-  }
-
-  public withCount(count:number):Logger {
-    this.withField('count', count);
-    return this;
-  }
-
-  public withDurationMillis(duration:number):Logger {
-    this.withField('duration_millis', duration);
-    return this;
-  }
-
-  public withDocVersion(version:number):Logger {
-    this.withField('doc_version', version);
-    return this;
-  }
-
-  public withWordCount(count:number):Logger {
-    this.withField('word_count', count);
-    return this;
-  }
-
-  public withBucket(bucket:string):Logger {
-    this.withField('bucket', bucket);
-    return this;
-  }
-
-  public withFileName(fileName:string):Logger {
-    this.withField('file_name', fileName);
-    return this;
-  }
-
-  public withFileSize(size:number):Logger {
-    this.withField('file_size', size);
-    return this;
-  }
-
-  public withRequestBody(body:any):Logger {
-    this.withField('request_body', Logger.ensureStringified(body));
-    return this;
-  }
-
-  public clearParams():Logger {
-    delete this.fields.params;
-    return this;
-  }
-
-  public withParams(params:any):Logger {
-    // Layer in the new params over the old params, if they exist.
-    const oldParams = this.fields.params;
-    if (oldParams) {
-      let oldParamsObj:any;
-      try {
-        oldParamsObj = JSON.parse(oldParams);
-      } catch (e) {
-        oldParamsObj = {};
-      }
-      this.fields.params = JSON.stringify({ ...oldParamsObj, ...params });
-    } else {
-      this.fields.params = JSON.stringify(params);
-    }
-    return this;
-  }
-
-  public withChangingData(originalData:any, transformedData:any):Logger {
-    this.withOriginalData(originalData);
-    this.withTransformedData(transformedData);
-    return this;
-  }
-
-  public withOriginalData(data:any):Logger {
-    this.withField('original_data', Logger.ensureStringified(data));
-    return this;
-  }
-
-  public withTransformedData(data:any):Logger {
-    this.withField('transformed_data', Logger.ensureStringified(data));
-    return this;
-  }
-
-  public withIgnoreConflict(ignoreConflict:boolean):Logger {
-    this.withField('ignore_conflict', ignoreConflict);
-    return this;
-  }
-
-  public withError(err:any):Logger {
-    let stringified:string;
-    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;
-  }
-
-  private static ensureStringified(value:any):string {
-    if (typeof value === 'string') {
-      return value;
-    } else {
-      return JSON.stringify(value);
-    }
-  }
-
-  private static enforceFieldType(key:string, value:any):void {
-    // 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}`);
-    }
-  }
-
-  private static makeTypeErrorMessage(key:string, value:any, expectedType:string):string {
-    return `invalid type for log field '${key}': ${typeof value}; expected ${expectedType}`;
-  }
-
-}
-
-// The LogFields type is used to record structured data in log entries. It is a key-value object,
-// with a set of well-known fields, and an open-ended set of additional fields. Part of the reason
-// this interface definiton exists is to enforce the types on well-known fields (because they will
-// be indexed into elasticsearch, and incorrect types for any of these fields will casuse indexing
-// errors). This list can grow over time, as new well-known fields are added to the logging system.
-export interface LogFields {
-
-  // 'service_name', 'version', and 'node_name' are used in server-logging, to record details about
-  // the service that recorded the log entry.
-  service_name?: string;
-  node_name?: string;
-  version?: string;
-
-  // 'client_type' and 'client_node_name' are used in server-logging, to record activities performed
-  // on behalf of either a user or another server node. Whenever 'client_type' is 'user', the 'user_id'
-  // field should be populated. Whenever 'client_type' is 'server', the 'client_node_name' field should
-  // be populated.
-  client_type?: ClientType;
-  client_service_name?: string;
-  client_node_name?: string;
-  client_version?: string;
-
-  // 'context' and 'name' are general-purpose fields used in all kinds of logging
-  context?: string;
-  name?: string;
-
-  // 'topic' and 'subtopic' are used in client-side activity tracking
-  topic?: string;
-  subtopic?: string;
-
-  // 'using_jwt' and 'using_pass_hash' are used in server-logging, to record whether the client is
-  // using a JWT or a password hash for authentication.
-  using_jwt?: boolean;
-  using_pass_hash?: boolean;
-
-  // 'user_id' and 'email' are used in all kinds of logging, anytime a specific user is relevant to the log entry.
-  user_id?: string;
-  email?: string;
-  url?: string;
-
-  // 'session_ref' is used in the desktop and browser clients, to record the session ID of the current session.
-  session_ref?: string;
-
-  // 'content_kind', 'content_ref', and 'doc_version' are used in all kinds of logging, to record
-  // the ShareDB identity and version of a relevant content item.
-  content_kind?: string;
-  content_ref?: string;
-  doc_version?: number;
-
-  // 'word_count' is used in all kinds of logging, to record the number of words in a relevant content item.
-  word_count?: number;
-
-  // 'bucket', 'file_name' and 'file_size' are used in all kinds of logging, to record the name and/or size of a relevant file
-  bucket?: string;
-  file_name?: string;
-  file_size?: number;
-
-  // 'count' and 'duration_millis' are used in all kinds of logging, with obvious meanings.
-  count?: number;
-  duration_millis?: number;
-
-  // 'request_body' and 'params' are used in server-logging, to record the body of an HTTP request,
-  // or the parameters of a function call. They are both strings, and should contain a JSON-serialized
-  // representation of the request body or parameters.
-  request_body?: string;
-  params?: string;
-
-  // 'original_data' and 'transformed_data' are used in all kinds of logging, to record the original
-  // and transformed data of a relevant content item. Since these are both strings, they should
-  // contain a JSON-serialized representation of the data.
-  original_data?: string;
-  transformed_data?: string;
-
-  // 'ignore_conflict' is used to record whether a conflict was ignored (e.g., during an elasticsearch indexing operation).
-  ignore_conflict?: boolean;
-
-  // 'error_body' is used in all logging, to record the body of any error object. Since it is a string field,
-  // it shoud contain a JSON-serialized representation of the error.
-  error_body?: string;
-
-  // This line in the LogFields type definition allows arbitrary fields to be added to the LogFields
-  // object, as long as the values are strings, numbers, or booleans.
-  [key: string]: string | number | boolean;
-}

package/lib/util/index.ts

@@ -1,4 +0,0 @@
-// created from 'create-ts-index'
-
-export * from './Encryption';
-export * from './Logging';

package/tsconfig.json

@@ -1,25 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "outDir": "./dist",
-    "noImplicitAny": true,
-    "alwaysStrict": true,
-    "target": "es2021",
-    "declaration": true,
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports":true,
-    "typeRoots": [
-      "./node_modules/@types"
-    ]
-  },
-  "include": [
-    "./lib/**/*",
-    "decs.d.ts"
-  ],
-  "baseUrl": "types",
-  "typeRoots": [
-    "types"
-  ]
-}

package/tslint.json

@@ -1,46 +0,0 @@
-{
-  "extends": "tslint:recommended",
-  "rules": {
-      "eofline": false,
-      "interface-name": false,
-      "max-classes-per-file": false,
-      "max-line-length": {
-          "options": [120]
-      },
-      "member-access": true,
-      "member-ordering": false,
-      "new-parens": true,
-      "no-arg": true,
-      "no-bitwise": true,
-      "no-conditional-assignment": true,
-      "no-consecutive-blank-lines": false,
-      "no-console": {
-          "severity": "warning",
-          "options": ["debug", "info", "log", "time", "timeEnd", "trace"]
-      },
-      "no-unused-variable": true,
-      "object-literal-key-quotes": false,
-      "object-literal-shorthand": false,
-      "object-literal-sort-keys": false,
-      "only-arrow-functions": false,
-      "prefer-const": false,
-      "prefer-for-of": false,
-      "quotemark": false,
-      "radix": false,
-      "trailing-comma": false,
-      "typedef": [true, "call-signature", "parameter"],
-      "typedef-whitespace": [true, {}, {
-        "call-signature": "nospace", 
-        "parameter": "nospace",
-        "property-declaration": "nospace",
-        "variable-declaration": "nospace"
-      }],
-      "variable-name": false,
-      "whitespace": false
-  },
-  "jsRules": {
-      "max-line-length": {
-          "options": [120]
-      }
-  }
-}