nsa-sheets-db-builder 4.0.0

package/libs/common/gas_response_helper.ts

@@ -0,0 +1,147 @@
+class GASStatusV2 {
+  type: 'OK' | 'WARNING' | 'ERROR';
+  message?: string;
+  timestamp: string;
+  traceId?: string;
+  error?: {
+    name: string;
+    source: string;
+    message: string;
+    context?: Record<string, any>;
+    originalError?: string;
+  };
+
+  constructor(type: 'OK' | 'WARNING' | 'ERROR', message?: string, traceId?: string, error?: any) {
+    this.type = type;
+    this.timestamp = formatDateTime();
+    this.traceId = traceId;
+
+    // Set message for OK and WARNING types
+    if ((type === 'OK' || type === 'WARNING') && message) {
+      this.message = message;
+    }
+
+    // Embed error details in status for ERROR type
+    if (type === 'ERROR' && error) {
+      this.error = error;
+    }
+  }
+
+  static OK(message?: string, traceId?: string): GASStatusV2 {
+    return new GASStatusV2('OK', message, traceId);
+  }
+
+  static Warning(message?: string, traceId?: string): GASStatusV2 {
+    return new GASStatusV2('WARNING', message, traceId);
+  }
+
+  static Error(traceId?: string, error?: any): GASStatusV2 {
+    return new GASStatusV2('ERROR', undefined, traceId, error);
+  }
+}
+
+class GASResponseV2 {
+  status: GASStatusV2;
+  result?: { [key: string]: any };
+
+  constructor(status: GASStatusV2, result?: { [key: string]: any }) {
+    this.status = status;
+
+    // Only include result for success/warning if provided
+    if ((status.type === 'OK' || status.type === 'WARNING') && result !== undefined) {
+      this.result = result;
+    }
+  }
+
+  static success(message?: string, result?: { [key: string]: any }, traceId?: string): GASResponseV2 {
+    return new GASResponseV2(GASStatusV2.OK(message, traceId), result);
+  }
+
+  static warning(message?: string, result?: { [key: string]: any }, traceId?: string): GASResponseV2 {
+    return new GASResponseV2(GASStatusV2.Warning(message, traceId), result);
+  }
+
+  static error(error: any): GASResponseV2 {
+    let errorObj: any;
+    let traceId: string | undefined;
+
+    if (error && error.name === 'GASErrorV2') {
+      traceId = error.traceId;
+      errorObj = {
+        name: error.name,
+        source: error.source,
+        message: error.message
+      };
+
+      // Only include context if not empty
+      if (error.context && Object.keys(error.context).length > 0) {
+        errorObj.context = error.context;
+      }
+
+      // Only include originalError if it exists and is not empty
+      if (error.originalError && error.originalError.trim() !== '') {
+        errorObj.originalError = error.originalError;
+      }
+    } else {
+      errorObj = {
+        name: 'Error',
+        source: 'Unknown',
+        message: error?.message || error?.toString() || 'Unknown error'
+      };
+    }
+
+    return new GASResponseV2(GASStatusV2.Error(traceId, errorObj));
+  }
+
+  toString(): string {
+    return JSON.stringify(this, null, 2);
+  }
+
+  getTraceId(): string | undefined {
+    return this.status.traceId;
+  }
+}
+
+class GASResponseBuilderV2 {
+  private traceId?: string;
+  private startTime?: number;
+  private operationId?: string;
+
+  constructor(traceId?: string) {
+    this.traceId = traceId;
+    this.startTime = new Date().getTime();
+    this.operationId = Utilities.getUuid();
+  }
+
+  setTraceId(traceId: string): this {
+    this.traceId = traceId;
+    return this;
+  }
+
+  setOperationId(operationId: string): this {
+    this.operationId = operationId;
+    return this;
+  }
+
+  success(message?: string, result?: { [key: string]: any }): GASResponseV2 {
+    return GASResponseV2.success(message, result, this.traceId);
+  }
+
+  warning(message?: string, result?: { [key: string]: any }): GASResponseV2 {
+    return GASResponseV2.warning(message, result, this.traceId);
+  }
+
+  error(error: any): GASResponseV2 {
+    // Ensure error has traceId set if it's a GASErrorV2
+    if (error && error.name === 'GASErrorV2' && !error.traceId && this.traceId) {
+      error.setTraceId(this.traceId);
+    }
+    return GASResponseV2.error(error);
+  }
+
+  criticalError(message: string): never {
+    throw new Error(message);
+  }
+}
+
+export { GASStatusV2, GASResponseV2, GASResponseBuilderV2 };

package/libs/common/gaserror.ts

@@ -0,0 +1,101 @@
+class GASErrorV2 extends Error {
+    public name: string;
+    public source: string;
+    public context: Record<string, any>;
+    public timestamp: string;
+    public traceId: string;
+    public originalError: string;
+
+    constructor(
+        message: string,
+        source: string,
+        context: Record<string, any> = {},
+        traceId?: string
+    ) {
+        super(message);
+        this.name = 'GASErrorV2';
+        this.message = message;
+        this.source = source;
+        this.context = context;
+        this.timestamp = formatDateTime();
+        this.traceId = traceId || '';
+        this.originalError = '';
+    }
+
+    setTraceId(traceId: string): this {
+        this.traceId = traceId;
+        return this;
+    }
+
+    getTraceId(): string {
+        return this.traceId;
+    }
+
+    static isGASErrorV2(error: any): boolean {
+        return error && error.name === 'GASErrorV2';
+    }
+
+    static handleError(
+        error: any,
+        message: string,
+        source: string,
+        context: Record<string, any> = {},
+        traceId?: string
+    ): never {
+        throw GASErrorV2.wrapError(error, message, source, context, traceId);
+    }
+
+    static wrapError(
+        error: any,
+        message: string,
+        source: string,
+        context: Record<string, any> = {},
+        traceId?: string
+    ): GASErrorV2 {
+        const newError = new GASErrorV2(message, source, context, traceId);
+
+        if (GASErrorV2.isGASErrorV2(error)) {
+            newError.originalError = error.message;
+            if (!traceId && error.traceId) {
+                newError.traceId = error.traceId;
+            }
+        } else if (error) {
+            newError.originalError = error.toString();
+        }
+
+        return newError;
+    }
+
+    static fromErrorGASResponseV2(response: any): GASErrorV2 {
+        const parsedError = response.error;
+        if (parsedError && parsedError.name === 'GASErrorV2' && parsedError.message && parsedError.source) {
+            const err = new GASErrorV2(
+                parsedError.message,
+                parsedError.source,
+                parsedError.context || {},
+                parsedError.traceId
+            );
+            err.originalError = parsedError.originalError || '';
+            return err;
+        }
+        throw new GASErrorV2(
+            "Invalid GASErrorV2 response",
+            "GASErrorV2.fromErrorGASResponseV2",
+            { response }
+        );
+    }
+
+    toJson(): string {
+        return JSON.stringify({
+            name: this.name,
+            source: this.source,
+            message: this.message,
+            context: this.context,
+            timestamp: this.timestamp,
+            traceId: this.traceId,
+            originalError: this.originalError
+        }, null, 2);
+    }
+}
+
+export default GASErrorV2;

package/libs/common/gaslogger.ts

@@ -0,0 +1,172 @@
+class GASLoggerV2 {
+    private webhookUrl: string | null;
+    private verbosityLevel: number;
+    private loggerId: string;
+    private traceId: string;
+
+    constructor(loggerId: string, webhookUrl: string | null = null, verbosityLevel: number = 1, traceId: string = '') {
+        this.loggerId = loggerId;
+        this.webhookUrl = webhookUrl;
+        this.verbosityLevel = verbosityLevel;
+        this.traceId = traceId;
+    }
+
+    setVerbosityLevel(level: number): void {
+        this.verbosityLevel = level;
+    }
+
+    setTraceId(traceId: string): void {
+        this.traceId = traceId;
+    }
+
+    getTraceId(): string {
+        return this.traceId;
+    }
+
+    error(error: GASErrorV2): void {
+        const originalErrorArray = error.originalError ? [error.originalError] : [];
+
+        this.log('ERROR', error.source, error.message,
+            error.context,
+            originalErrorArray,
+            error.traceId
+        );
+    }
+
+    warn(source: string, message: string, context: any = {}, errors: any[] = [], traceId?: string): void {
+        this.log('WARNING', source, message, context, errors, traceId);
+    }
+
+    info(source: string, message: string, context: any, traceId?: string): void {
+        this.log('INFO', source, message, context, [], traceId);
+    }
+
+    debug(source: string, message: string, context: any = {}, errors: any[] = [], traceId?: string): void {
+        this.log('DEBUG', source, message, context, errors, traceId);
+    }
+
+    private log(type: 'DEBUG' | 'INFO' | 'WARNING' | 'ERROR', source: string, message: string, context: any = {}, errors: any[] = [], traceId?: string): void {
+
+        if (
+            (this.verbosityLevel === 1 && type === 'ERROR') ||
+            (this.verbosityLevel === 2 && (type === 'ERROR' || type === 'WARNING')) ||
+            (this.verbosityLevel === 3 && (type === 'ERROR' || type === 'WARNING' || type === 'INFO')) ||
+            (this.verbosityLevel === 4)
+        ) {
+            const logId = this.generateLogId();
+            const timestamp = formatDateTime();
+            const fullSource = `${source}`;
+            const effectiveTraceId = traceId || this.traceId;
+
+            const logEntry: any = {
+                type: type,
+                source: fullSource,
+                message: message,
+                timestamp: timestamp,
+                logId: logId,
+                traceId: effectiveTraceId,
+                pipeline: this.loggerId,
+
+            };
+            if (context) {
+                logEntry.context = context;
+            }
+            if (errors) {
+                logEntry.errors = errors;
+            }
+
+            this.outputToConsole(type, logEntry);
+
+            if (type === 'ERROR' && this.webhookUrl) {
+                this.sendToChat(logEntry);
+            }
+        }
+    }
+
+    private outputToConsole(type: string, logEntry: any): void {
+        switch (type) {
+            case 'ERROR':
+                console.error(JSON.stringify(logEntry, null, 2));
+                break;
+            case 'WARNING':
+                console.warn(logEntry);
+                break;
+            case 'INFO':
+                console.log(logEntry);
+                break;
+            case 'DEBUG':
+                console.log(logEntry);
+                break;
+        }
+    }
+
+    private sendToChat(logEntry: { [key: string]: any }): void {
+        if (!this.webhookUrl) return;
+
+        const errorIcon = logEntry.type === 'ERROR' ? '❗ ' : '';
+
+        const jsonCardData: CardData = {
+            type: 'json',
+            header: `${errorIcon}${logEntry.source}`,
+            widgetSpecs: [
+                {
+                    header: 'Error',
+                    collapsible: false,
+                    data: {
+                        'Pipeline': logEntry.pipeline,
+                        'Message': logEntry.message,
+                        'Timestamp': logEntry.timestamp,
+                        'TraceId': logEntry.traceId,
+                    },
+                },
+                {
+                  header: 'Context',
+                  collapsible: true,
+                  data: logEntry.context || {},
+                },
+              {
+                header: 'Error Stack',
+                collapsible: true,
+                data: logEntry.errors || [],
+              },
+              {
+                header: 'Logs',
+                collapsible: false,
+                data: {
+                    'LogId': logEntry.logId,
+                    'TraceId': logEntry.traceId,
+                },
+              },
+            ],
+        };
+
+        const card = CardFactory.createCardSpec(jsonCardData);
+
+        const payload = {
+            cardsV2: [
+                {
+                    cardId: 'errorCard',
+                    card: card,
+                },
+            ],
+        };
+
+        const chatService = new GoogleChatService(this.webhookUrl);
+        chatService.sendMessage(JSON.stringify(payload));
+    }
+
+    private generateLogId(): string {
+        return Utilities.getUuid();
+    }
+
+    createChildLogger(traceId?: string): GASLoggerV2 {
+        return new GASLoggerV2(
+            this.loggerId,
+            this.webhookUrl,
+            this.verbosityLevel,
+            traceId || this.traceId
+        );
+    }
+}
+
+export default GASLoggerV2;