Feature: Add Typescript

index.ts

@@ -0,0 +1,147 @@
+import type {
+  CompleteHandler,
+  ErrorHandler,
+  Handlers,
+  HTTP_METHOD,
+  HTTP_STATUS,
+  NextHandler,
+  ObservableLike,
+  ObserverLike,
+  Request,
+  RequestError,
+  Subscription,
+  SubscribeFn,
+  Unsubscribe,
+  User,
+} from './types';
+
+class Observer implements ObserverLike {
+  private handlers: Handlers;
+  private isUnsubscribed: boolean;
+  public _unsubscribe?: Unsubscribe;
+
+  constructor(handlers: Handlers) {
+    this.handlers = handlers;
+    this.isUnsubscribed = false;
+  }
+
+  next(value: Request): void {
+    if (this.handlers.next && !this.isUnsubscribed) {
+      this.handlers.next(value);
+    }
+  }
+
+  error(error: RequestError): void {
+    if (!this.isUnsubscribed) {
+      if (this.handlers.error) {
+        this.handlers.error(error);
+      }
+
+      this.unsubscribe();
+    }
+  }
+
+  complete(): void {
+    if (!this.isUnsubscribed) {
+      if (this.handlers.complete) {
+        this.handlers.complete();
+      }
+
+      this.unsubscribe();
+    }
+  }
+
+  unsubscribe(): void {
+    this.isUnsubscribed = true;
+
+    if (this._unsubscribe) {
+      this._unsubscribe();
+    }
+  }
+}
+
+class Observable implements ObservableLike {
+  private _subscribe: SubscribeFn;
+
+  constructor(subscribe: SubscribeFn) {
+    this._subscribe = subscribe;
+  }
+
+  static from(values: Request[]): Observable {
+    return new Observable((observer: ObserverLike): Unsubscribe => {
+      values.forEach((value: Request) => observer.next(value));
+
+      observer.complete();
+
+      return (): void => {
+        console.log('unsubscribed');
+      };
+    });
+  }
+
+  subscribe(obs: Handlers): Subscription {
+    const observer = new Observer(obs);
+
+    observer._unsubscribe = this._subscribe(observer);
+
+    return {
+      unsubscribe(): void {
+        observer.unsubscribe();
+      },
+    };
+  }
+}
+
+const HTTP_POST_METHOD: HTTP_METHOD = 'POST';
+const HTTP_GET_METHOD: HTTP_METHOD = 'GET';
+
+const HTTP_STATUS_OK: HTTP_STATUS = 200;
+const HTTP_STATUS_INTERNAL_SERVER_ERROR: HTTP_STATUS = 500;
+
+const userMock: User = {
+  name: 'User Name',
+  age: 26,
+  roles: ['user', 'admin'],
+  createdAt: new Date(),
+  isDeleated: false,
+};
+
+const requestsMock: Request[] = [
+  {
+    method: HTTP_POST_METHOD,
+    host: 'service.example',
+    path: 'user',
+    body: userMock,
+    params: {},
+  },
+  {
+    method: HTTP_GET_METHOD,
+    host: 'service.example',
+    path: 'user',
+    params: {
+      id: '3f5h67s4s',
+    },
+  },
+];
+
+const handleRequest: NextHandler = (request: Request) => {
+  // handling of request
+  return { status: HTTP_STATUS_OK };
+};
+
+const handleError: ErrorHandler = (error: RequestError) => {
+  // handling of error
+  return { status: HTTP_STATUS_INTERNAL_SERVER_ERROR };
+};
+
+const handleComplete: CompleteHandler = () => console.log('complete');
+
+const requests$: ObservableLike = Observable.from(requestsMock);
+
+const subscription: Subscription = requests$.subscribe({
+  next: handleRequest,
+  error: handleError,
+  complete: handleComplete,
+});
+
+subscription.unsubscribe();

tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "noEmit": true,
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "skipLibCheck": true
+  },
+  "include": ["**/*.ts"]
+}

types/handlers.ts

@@ -0,0 +1,11 @@
+import type { Request, RequestError, HandlerResponse } from './request';
+
+export type NextHandler = (request: Request) => HandlerResponse;
+export type ErrorHandler = (error: RequestError) => HandlerResponse;
+export type CompleteHandler = () => void;
+
+export type Handlers = {
+  next?: NextHandler;
+  error?: ErrorHandler;
+  complete?: CompleteHandler;
+};

types/http.ts

@@ -0,0 +1,2 @@
+export type HTTP_METHOD = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
+export type HTTP_STATUS = 200 | 500;

types/index.ts

@@ -0,0 +1,18 @@
+export type { HTTP_METHOD, HTTP_STATUS } from './http';
+export type { UserRole, User } from './user';
+export type {
+  PostRequest,
+  GetRequest,
+  Request,
+  RequestError,
+  HandlerResponse,
+} from './request';
+export type {
+  NextHandler,
+  ErrorHandler,
+  CompleteHandler,
+  Handlers,
+} from './handlers';
+export type { Unsubscribe, Subscription } from './subscription';
+export type { ObserverLike } from './observer';
+export type { SubscribeFn, ObservableLike, ObservableFactory } from './observable';

types/observable.ts

@@ -0,0 +1,14 @@
+import type { Handlers } from './handlers';
+import type { ObserverLike } from './observer';
+import type { Request } from './request';
+import type { Subscription, Unsubscribe } from './subscription';
+
+export type SubscribeFn = (observer: ObserverLike) => Unsubscribe;
+
+export type ObservableLike = {
+  subscribe: (handlers: Handlers) => Subscription;
+};
+
+export type ObservableFactory = {
+  from: (values: Request[]) => ObservableLike;
+};

types/observer.ts

@@ -0,0 +1,7 @@
+import type { Request, RequestError } from './request';
+
+export type ObserverLike = {
+  next: (value: Request) => void;
+  error: (error: RequestError) => void;
+  complete: () => void;
+};

types/request.ts

@@ -0,0 +1,28 @@
+import type { HTTP_STATUS } from './http';
+import type { User } from './user';
+
+export type PostRequest = {
+  method: 'POST';
+  host: string;
+  path: string;
+  body: User;
+  params?: Record<string, string>;
+};
+
+export type GetRequest = {
+  method: 'GET';
+  host: string;
+  path: string;
+  params: Record<string, string>;
+};
+
+export type Request = PostRequest | GetRequest;
+
+export type RequestError = {
+  message: string;
+  code?: string;
+};
+
+export type HandlerResponse = {
+  status: HTTP_STATUS;
+};

types/subscription.ts

@@ -0,0 +1,5 @@
+export type Unsubscribe = () => void;
+
+export type Subscription = {
+  unsubscribe: () => void;
+};

types/user.ts

@@ -0,0 +1,9 @@
+export type UserRole = 'user' | 'admin';
+
+export type User = {
+  name: string;
+  age: number;
+  roles: UserRole[];
+  createdAt: Date;
+  isDeleated: boolean;
+};