feat: move data center to root

packages/data-center/src/apis/index.ts

@@ -0,0 +1,17 @@
+export { token } from './token.js';
+export type { Callback } from './token.js';
+
+import { getAuthorizer } from './token.js';
+import * as user from './user.js';
+import * as workspace from './workspace.js';
+
+export type Apis = typeof user &
+  typeof workspace & {
+    signInWithGoogle: ReturnType<typeof getAuthorizer>[0];
+    onAuthStateChanged: ReturnType<typeof getAuthorizer>[1];
+  };
+
+export const getApis = (): Apis => {
+  const [signInWithGoogle, onAuthStateChanged] = getAuthorizer();
+  return { ...user, ...workspace, signInWithGoogle, onAuthStateChanged };
+};

packages/data-center/src/apis/request.ts

@@ -0,0 +1,45 @@
+import kyOrigin from 'ky';
+import ky from 'ky-universal';
+import { token } from './token.js';
+
+export const bareClient = ky.extend({
+  prefixUrl: 'http://localhost:8080',
+  retry: 1,
+  hooks: {
+    // afterResponse: [
+    //   async (_request, _options, response) => {
+    //     if (response.status === 200) {
+    //       const data = await response.json();
+    //       if (data.error) {
+    //         return new Response(data.error.message, {
+    //           status: data.error.code,
+    //         });
+    //       }
+    //     }
+    //     return response;
+    //   },
+    // ],
+  },
+});
+
+export const client = bareClient.extend({
+  hooks: {
+    beforeRequest: [
+      async request => {
+        if (token.isLogin) {
+          if (token.isExpired) await token.refreshToken();
+          request.headers.set('Authorization', token.token);
+        } else {
+          return new Response('Unauthorized', { status: 401 });
+        }
+      },
+    ],
+
+    beforeRetry: [
+      async ({ request }) => {
+        await token.refreshToken();
+        request.headers.set('Authorization', token.token);
+      },
+    ],
+  },
+});

packages/data-center/src/apis/token.ts

@@ -0,0 +1,170 @@
+import { initializeApp } from 'firebase/app';
+import { getAuth, GoogleAuthProvider, signInWithPopup } from 'firebase/auth';
+import type { User } from 'firebase/auth';
+
+import { getLogger } from '../index.js';
+import { bareClient } from './request.js';
+
+interface AccessTokenMessage {
+  create_at: number;
+  exp: number;
+  email: string;
+  id: string;
+  name: string;
+  avatar_url: string;
+}
+
+export type Callback = (user: AccessTokenMessage | null) => void;
+
+type LoginParams = {
+  type: 'Google' | 'Refresh';
+  token: string;
+};
+
+type LoginResponse = {
+  // access token, expires in a very short time
+  token: string;
+  // Refresh token
+  refresh: string;
+};
+
+const login = (params: LoginParams): Promise<LoginResponse> =>
+  bareClient.post('api/user/token', { json: params }).json();
+
+class Token {
+  private readonly _logger;
+  private _accessToken!: string;
+  private _refreshToken!: string;
+
+  private _user!: AccessTokenMessage | null;
+  private _padding?: Promise<LoginResponse>;
+
+  constructor() {
+    this._logger = getLogger('token');
+    this._logger.enabled = true;
+
+    this._setToken(); // fill with default value
+  }
+
+  private _setToken(login?: LoginResponse) {
+    this._accessToken = login?.token || '';
+    this._refreshToken = login?.refresh || '';
+
+    this._user = Token.parse(this._accessToken);
+    if (login) {
+      this._logger('set login', login);
+      this.triggerChange(this._user);
+    } else {
+      this._logger('empty login');
+    }
+  }
+
+  async initToken(token: string) {
+    this._setToken(await login({ token, type: 'Google' }));
+  }
+
+  async refreshToken(token?: string) {
+    if (!this._refreshToken && !token) {
+      throw new Error('No authorization token.');
+    }
+    if (!this._padding) {
+      this._padding = login({
+        type: 'Refresh',
+        token: this._refreshToken || token!,
+      });
+    }
+    this._setToken(await this._padding);
+    this._padding = undefined;
+  }
+
+  get token() {
+    return this._accessToken;
+  }
+
+  get refresh() {
+    return this._refreshToken;
+  }
+
+  get isLogin() {
+    return !!this._refreshToken;
+  }
+
+  get isExpired() {
+    if (!this._user) return true;
+    return Date.now() - this._user.create_at > this._user.exp;
+  }
+
+  static parse(token: string): AccessTokenMessage | null {
+    try {
+      return JSON.parse(
+        String.fromCharCode.apply(
+          null,
+          Array.from(
+            Uint8Array.from(
+              window.atob(
+                // split jwt
+                token.split('.')[1]
+              ),
+              c => c.charCodeAt(0)
+            )
+          )
+        )
+      );
+    } catch (error) {
+      return null;
+    }
+  }
+
+  private callbacks: Callback[] = [];
+  private lastState: AccessTokenMessage | null = null;
+
+  triggerChange(user: AccessTokenMessage | null) {
+    this.lastState = user;
+    this.callbacks.forEach(callback => callback(user));
+  }
+
+  onChange(callback: Callback) {
+    this.callbacks.push(callback);
+    callback(this.lastState);
+  }
+
+  offChange(callback: Callback) {
+    const index = this.callbacks.indexOf(callback);
+    if (index > -1) {
+      this.callbacks.splice(index, 1);
+    }
+  }
+}
+
+export const token = new Token();
+
+export const getAuthorizer = () => {
+  const app = initializeApp({
+    apiKey: process.env.NEXT_PUBLIC_FIREBASE_API_KEY,
+    authDomain: process.env.NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN,
+    projectId: process.env.NEXT_PUBLIC_FIREBASE_PROJECT_ID,
+    storageBucket: process.env.NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET,
+    messagingSenderId: process.env.NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID,
+    appId: process.env.NEXT_PUBLIC_FIREBASE_APP_ID,
+    measurementId: process.env.NEXT_PUBLIC_FIREBASE_MEASUREMENT_ID,
+  });
+  try {
+    const firebaseAuth = getAuth(app);
+
+    const googleAuthProvider = new GoogleAuthProvider();
+
+    const signInWithGoogle = async () => {
+      const user = await signInWithPopup(firebaseAuth, googleAuthProvider);
+      const idToken = await user.user.getIdToken();
+      await token.initToken(idToken);
+    };
+
+    const onAuthStateChanged = (callback: (user: User | null) => void) => {
+      firebaseAuth.onAuthStateChanged(callback);
+    };
+
+    return [signInWithGoogle, onAuthStateChanged] as const;
+  } catch (e) {
+    return [] as const;
+  }
+};

packages/data-center/src/apis/user.ts

@@ -0,0 +1,21 @@
+import { client } from './request.js';
+
+export interface GetUserByEmailParams {
+  email: string;
+  workspace_id: string;
+}
+
+export interface User {
+  id: string;
+  name: string;
+  email: string;
+  avatar_url: string;
+  create_at: string;
+}
+
+export async function getUserByEmail(
+  params: GetUserByEmailParams
+): Promise<User | null> {
+  const searchParams = new URLSearchParams({ ...params });
+  return client.get('api/user', { searchParams }).json<User | null>();
+}

packages/data-center/src/apis/workspace.ts

@@ -0,0 +1,176 @@
+import { bareClient, client } from './request.js';
+import type { User } from './user';
+
+export interface GetWorkspaceDetailParams {
+  id: string;
+}
+
+export enum WorkspaceType {
+  Private = 0,
+  Normal = 1,
+}
+
+export enum PermissionType {
+  Read = 0,
+  Write = 1,
+  Admin = 2,
+  Owner = 99,
+}
+
+export interface Workspace {
+  id: string;
+  type: WorkspaceType;
+  public: boolean;
+  permission_type: PermissionType;
+  create_at: number;
+}
+
+export async function getWorkspaces(): Promise<Workspace[]> {
+  return client
+    .get('api/workspace', {
+      headers: {
+        'Cache-Control': 'no-cache',
+      },
+    })
+    .json();
+}
+
+export interface WorkspaceDetail extends Workspace {
+  owner: User;
+  member_count: number;
+}
+
+export async function getWorkspaceDetail(
+  params: GetWorkspaceDetailParams
+): Promise<WorkspaceDetail | null> {
+  return client.get(`api/workspace/${params.id}`).json();
+}
+
+export interface Permission {
+  id: number;
+  type: PermissionType;
+  workspace_id: string;
+  accepted: boolean;
+  create_at: number;
+}
+
+export interface RegisteredUser extends User {
+  type: 'Registered';
+}
+
+export interface UnregisteredUser {
+  type: 'Unregistered';
+  email: string;
+}
+
+export interface Member extends Permission {
+  user: RegisteredUser | UnregisteredUser;
+}
+
+export interface GetWorkspaceMembersParams {
+  id: string;
+}
+
+export async function getWorkspaceMembers(
+  params: GetWorkspaceDetailParams
+): Promise<Member[]> {
+  return client.get(`api/workspace/${params.id}/permission`).json();
+}
+
+export interface CreateWorkspaceParams {
+  name: string;
+  avatar: string;
+}
+
+export async function createWorkspace(
+  params: CreateWorkspaceParams
+): Promise<void> {
+  return client.post('api/workspace', { json: params }).json();
+}
+
+export interface UpdateWorkspaceParams {
+  id: string;
+  public: boolean;
+}
+
+export async function updateWorkspace(
+  params: UpdateWorkspaceParams
+): Promise<{ public: boolean | null }> {
+  return client
+    .post(`api/workspace/${params.id}`, {
+      json: {
+        public: params.public,
+      },
+    })
+    .json();
+}
+
+export interface DeleteWorkspaceParams {
+  id: string;
+}
+
+export async function deleteWorkspace(
+  params: DeleteWorkspaceParams
+): Promise<void> {
+  await client.delete(`api/workspace/${params.id}`);
+}
+
+export interface InviteMemberParams {
+  id: string;
+  email: string;
+}
+
+/**
+ * Notice: Only support normal(contrast to private) workspace.
+ */
+export async function inviteMember(params: InviteMemberParams): Promise<void> {
+  return client
+    .post(`api/workspace/${params.id}/permission`, {
+      json: {
+        email: params.email,
+      },
+    })
+    .json();
+}
+
+export interface RemoveMemberParams {
+  permissionId: number;
+}
+
+export async function removeMember(params: RemoveMemberParams): Promise<void> {
+  await client.delete(`api/permission/${params.permissionId}`);
+}
+
+export interface AcceptInvitingParams {
+  invitingCode: string;
+}
+
+export async function acceptInviting(
+  params: AcceptInvitingParams
+): Promise<void> {
+  await bareClient.post(`api/invitation/${params.invitingCode}`);
+}
+
+export async function uploadBlob(params: { blob: Blob }): Promise<string> {
+  return client.put('api/blob', { body: params.blob }).text();
+}
+
+export async function getBlob(params: {
+  blobId: string;
+}): Promise<ArrayBuffer> {
+  return client.get(`api/blob/${params.blobId}`).arrayBuffer();
+}
+
+export interface LeaveWorkspaceParams {
+  id: number | string;
+}
+
+export async function leaveWorkspace({ id }: LeaveWorkspaceParams) {
+  await client.delete(`api/workspace/${id}/permission`).json();
+}
+
+export async function downloadWorkspace(
+  workspaceId: string
+): Promise<ArrayBuffer> {
+  return client.get(`api/workspace/${workspaceId}/doc`).arrayBuffer();
+}