ref: Move public interfaces to @sentry/types package (#1889)

* fix: Events created from exception shouldnt have top-level message attribute (#1831)
* Use SyncPromise internally & Remove deprecated API & Trim Public API (#1858)
* ref: Move PromiseBuffer and Error to utils package
* ref: Remove all async api
* ref: Remove invokeClientAsync function
* feat: Finish Node SDK
* feat: SyncPromise implementation
* fix: Browser SDK
* fix: beforeSend callback
* fix: Core tests
* fix: linting and tests
* fix: browser npm package + add error for manual tests
* meta: Remove deprecations
* fix: Typedocs and public exposed functions
* meta: Changelog
* Apply suggestions from code review
* ref: Move public interfaces to types package
* fix: Tests
* fix: Small type issues
* ref: Remove scope listeners
* fix: Add flush to interface
* ref: Remove interfaces from core

Author: HazAT

CHANGELOG.md

@@ -10,7 +10,7 @@ since we removed some methods from the public API and removed some classes from
 
 - **breaking** [node] fix: Events created from exception shouldn't have top-level message attribute
 - [utils] ref: Update wrap method to hide internal sentry flags
-- [utils] fix: Make internal Sentry flags non-enumerable in fill util
+- [utils] fix: Make internal Sentry flags non-enumerable in fill utils
 - [utils] ref: Move `SentryError` + `PromiseBuffer` to utils
 - **breaking** [core] ref: Use `SyncPromise` internally, this reduces memory pressure by a lot.
 - **breaking** [browser] ref: Removed `BrowserBackend` from default export.

packages/browser/rollup.config.js

@@ -66,7 +66,7 @@ export default [
       interop: false,
       sourcemap: true,
     },
-    external: ['@sentry/core', '@sentry/hub', '@sentry/minimal'],
+    external: ['@sentry/core', '@sentry/hub', '@sentry/minimal', 'tslib'],
     plugins: [
       typescript({
         tsconfig: 'tsconfig.build.json',

packages/browser/src/backend.ts

@@ -1,5 +1,5 @@
-import { BaseBackend, Options } from '@sentry/core';
-import { SentryEvent, SentryEventHint, Severity, Transport } from '@sentry/types';
+import { BaseBackend } from '@sentry/core';
+import { Event, EventHint, Options, Severity, Transport } from '@sentry/types';
 import { isDOMError, isDOMException, isError, isErrorEvent, isPlainObject } from '@sentry/utils/is';
 import { supportsBeacon, supportsFetch } from '@sentry/utils/supports';
 import { SyncPromise } from '@sentry/utils/syncpromise';
@@ -56,8 +56,8 @@ export class BrowserBackend extends BaseBackend<BrowserOptions> {
   /**
    * @inheritDoc
    */
-  public eventFromException(exception: any, hint?: SentryEventHint): SyncPromise<SentryEvent> {
-    let event: SentryEvent;
+  public eventFromException(exception: any, hint?: EventHint): SyncPromise<Event> {
+    let event: Event;
 
     if (isErrorEvent(exception as ErrorEvent) && (exception as ErrorEvent).error) {
       // If it is an ErrorEvent with `error` property, extract it to get actual Error
@@ -108,7 +108,7 @@ export class BrowserBackend extends BaseBackend<BrowserOptions> {
   /**
    * This is an internal helper function that creates an event.
    */
-  private buildEvent(event: SentryEvent, hint?: SentryEventHint): SentryEvent {
+  private buildEvent(event: Event, hint?: EventHint): Event {
     return {
       ...event,
       event_id: hint && hint.event_id,
@@ -125,12 +125,8 @@ export class BrowserBackend extends BaseBackend<BrowserOptions> {
   /**
    * @inheritDoc
    */
-  public eventFromMessage(
-    message: string,
-    level: Severity = Severity.Info,
-    hint?: SentryEventHint,
-  ): SyncPromise<SentryEvent> {
-    const event: SentryEvent = {
+  public eventFromMessage(message: string, level: Severity = Severity.Info, hint?: EventHint): SyncPromise<Event> {
+    const event: Event = {
       event_id: hint && hint.event_id,
       level,
       message,

packages/browser/src/client.ts

@@ -1,5 +1,5 @@
 import { API, BaseClient, Scope } from '@sentry/core';
-import { DsnLike, SentryEvent, SentryEventHint } from '@sentry/types';
+import { DsnLike, Event, EventHint } from '@sentry/types';
 import { logger } from '@sentry/utils/logger';
 import { getGlobalObject } from '@sentry/utils/misc';
 import { SyncPromise } from '@sentry/utils/syncpromise';
@@ -50,7 +50,7 @@ export class BrowserClient extends BaseClient<BrowserBackend, BrowserOptions> {
   /**
    * @inheritDoc
    */
-  protected prepareEvent(event: SentryEvent, scope?: Scope, hint?: SentryEventHint): SyncPromise<SentryEvent | null> {
+  protected prepareEvent(event: Event, scope?: Scope, hint?: EventHint): SyncPromise<Event | null> {
     event.platform = event.platform || 'javascript';
     event.sdk = {
       ...event.sdk,

packages/browser/src/index.ts

@@ -2,9 +2,9 @@ export {
   Breadcrumb,
   Request,
   SdkInfo,
-  SentryEvent,
-  SentryException,
-  SentryResponse,
+  Event,
+  Exception,
+  Response,
   Severity,
   StackFrame,
   Stacktrace,

packages/browser/src/integrations/breadcrumbs.ts

@@ -1,5 +1,5 @@
 import { API, getCurrentHub } from '@sentry/core';
-import { Breadcrumb, Integration, SentryBreadcrumbHint, Severity } from '@sentry/types';
+import { Breadcrumb, BreadcrumbHint, Integration, Severity } from '@sentry/types';
 import { isFunction, isString } from '@sentry/utils/is';
 import { logger } from '@sentry/utils/logger';
 import { getEventDescription, getGlobalObject, parseUrl } from '@sentry/utils/misc';
@@ -454,9 +454,9 @@ export class Breadcrumbs implements Integration {
   /**
    * Helper that checks if integration is enabled on the client.
    * @param breadcrumb Breadcrumb
-   * @param hint SentryBreadcrumbHint
+   * @param hint BreadcrumbHint
    */
-  public static addBreadcrumb(breadcrumb: Breadcrumb, hint?: SentryBreadcrumbHint): void {
+  public static addBreadcrumb(breadcrumb: Breadcrumb, hint?: BreadcrumbHint): void {
     if (getCurrentHub().getIntegration(Breadcrumbs)) {
       getCurrentHub().addBreadcrumb(breadcrumb, hint);
     }

packages/browser/src/integrations/globalhandlers.ts

@@ -1,5 +1,5 @@
 import { getCurrentHub } from '@sentry/core';
-import { Integration, SentryEvent } from '@sentry/types';
+import { Event, Integration } from '@sentry/types';
 import { logger } from '@sentry/utils/logger';
 import { safeNormalize, serialize } from '@sentry/utils/object';
 import { truncate } from '@sentry/utils/string';
@@ -83,11 +83,11 @@ export class GlobalHandlers implements Integration {
   }
 
   /**
-   * This function creates an SentryEvent from an TraceKitStackTrace.
+   * This function creates an Event from an TraceKitStackTrace.
    *
-   * @param stacktrace TraceKitStackTrace to be converted to an SentryEvent.
+   * @param stacktrace TraceKitStackTrace to be converted to an Event.
    */
-  private eventFromGlobalHandler(stacktrace: TraceKitStackTrace): SentryEvent {
+  private eventFromGlobalHandler(stacktrace: TraceKitStackTrace): Event {
     const event = eventFromStacktrace(stacktrace);
 
     const data: { [key: string]: string } = {
@@ -102,7 +102,7 @@ export class GlobalHandlers implements Integration {
       data.name = stacktrace.name;
     }
 
-    const newEvent: SentryEvent = {
+    const newEvent: Event = {
       ...event,
       exception: {
         ...event.exception,

packages/browser/src/integrations/helpers.ts

@@ -1,5 +1,5 @@
 import { captureException, getCurrentHub, withScope } from '@sentry/core';
-import { Mechanism, SentryEvent, SentryWrappedFunction } from '@sentry/types';
+import { Event as SentryEvent, Mechanism, WrappedFunction } from '@sentry/types';
 import { isFunction } from '@sentry/utils/is';
 import { htmlTreeAsString } from '@sentry/utils/misc';
 import { safeNormalize } from '@sentry/utils/object';
@@ -36,11 +36,11 @@ export function ignoreNextOnError(): void {
  * @hidden
  */
 export function wrap(
-  fn: SentryWrappedFunction,
+  fn: WrappedFunction,
   options: {
     mechanism?: Mechanism;
   } = {},
-  before?: SentryWrappedFunction,
+  before?: WrappedFunction,
 ): any {
   if (!isFunction(fn)) {
     return fn;
@@ -63,7 +63,7 @@ export function wrap(
     return fn;
   }
 
-  const sentryWrapped: SentryWrappedFunction = function(this: any): void {
+  const sentryWrapped: WrappedFunction = function(this: any): void {
     if (before && isFunction(before)) {
       before.apply(this, arguments);
     }

packages/browser/src/integrations/linkederrors.ts

@@ -1,5 +1,5 @@
 import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';
-import { Integration, SentryEvent, SentryEventHint, SentryException } from '@sentry/types';
+import { Event, EventHint, Exception, Integration } from '@sentry/types';
 import { exceptionFromStacktrace } from '../parsers';
 import { computeStackTrace } from '../tracekit';
 
@@ -47,7 +47,7 @@ export class LinkedErrors implements Integration {
    * @inheritDoc
    */
   public setupOnce(): void {
-    addGlobalEventProcessor((event: SentryEvent, hint?: SentryEventHint) => {
+    addGlobalEventProcessor((event: Event, hint?: EventHint) => {
       const self = getCurrentHub().getIntegration(LinkedErrors);
       if (self) {
         return self.handler(event, hint);
@@ -59,7 +59,7 @@ export class LinkedErrors implements Integration {
   /**
    * @inheritDoc
    */
-  public handler(event: SentryEvent, hint?: SentryEventHint): SentryEvent | null {
+  public handler(event: Event, hint?: EventHint): Event | null {
     if (!event.exception || !event.exception.values || !hint || !(hint.originalException instanceof Error)) {
       return event;
     }
@@ -71,7 +71,7 @@ export class LinkedErrors implements Integration {
   /**
    * @inheritDoc
    */
-  public walkErrorTree(error: ExtendedError, key: string, stack: SentryException[] = []): SentryException[] {
+  public walkErrorTree(error: ExtendedError, key: string, stack: Exception[] = []): Exception[] {
     if (!(error[key] instanceof Error) || stack.length + 1 >= this.limit) {
       return stack;
     }

packages/browser/src/integrations/pluggable/ember.ts

@@ -1,5 +1,5 @@
 import { captureException, captureMessage, getCurrentHub, Scope, withScope } from '@sentry/core';
-import { Integration, SentryEvent } from '@sentry/types';
+import { Event, Integration } from '@sentry/types';
 import { logger } from '@sentry/utils/logger';
 import { getGlobalObject } from '@sentry/utils/misc';
 
@@ -81,7 +81,7 @@ export class Ember implements Integration {
    * @param scope The scope currently used.
    */
   private addIntegrationToSdkInfo(scope: Scope): void {
-    scope.addEventProcessor((event: SentryEvent) => {
+    scope.addEventProcessor((event: Event) => {
       if (event.sdk) {
         const integrations = event.sdk.integrations || [];
         event.sdk = {