@solar-taro/planets 0.0.0

package/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 1.0.1 (2025-01-22)
+
+This was a version bump only for planets to align it with other projects, there were no code changes.

package/README.md

@@ -0,0 +1,11 @@
+# planets
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build planets` to build the library.
+
+## Running unit tests
+
+Run `nx test planets` to execute the unit tests via [Vitest](https://vitest.dev/).

package/eslint.config.cjs

@@ -0,0 +1,22 @@
+const baseConfig = require('../../eslint.config.cjs');
+
+module.exports = [
+  ...baseConfig,
+  {
+    files: ['**/*.json'],
+    rules: {
+      '@nx/dependency-checks': [
+        'error',
+        {
+          ignoredFiles: [
+            '{projectRoot}/eslint.config.{js,cjs,mjs}',
+            '{projectRoot}/vite.config.{js,ts,mjs,mts}',
+          ],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: require('jsonc-eslint-parser'),
+    },
+  },
+];

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@solar-taro/planets",
+  "version": "0.0.0",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}

package/project.json

@@ -0,0 +1,47 @@
+{
+  "name": "planets",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/planets/src",
+  "projectType": "library",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": [
+        "{options.outputPath}"
+      ],
+      "options": {
+        "outputPath": "dist/planets",
+        "main": "packages/planets/src/index.ts",
+        "tsConfig": "packages/planets/tsconfig.lib.json",
+        "assets": [
+          "packages/planets/*.md"
+        ],
+        "additionalEntryPoints": [
+          "packages/planets/src/earth/index.ts",
+          "packages/planets/src/mercury/index.ts"
+        ],
+        "generateExportsField": true
+      }
+    },
+    "postbuild": {
+      "executor": "nx:run-commands",
+      "dependsOn": [
+        "build"
+      ],
+      "options": {
+        "commands": [
+          "node scripts/postbuild.js planets"
+        ]
+      }
+    },
+    "release:dev": {
+      "executor": "nx:run-commands",
+      "options": {
+        "commands": [
+          "yalc publish dist/planets"
+        ]
+      }
+    }
+  }
+}

package/src/earth/index.ts

@@ -0,0 +1,2 @@
+export * from './object-storage.service';
+export * from './service';

package/src/earth/object-storage.service.ts

@@ -0,0 +1,37 @@
+import { HttpClient, HttpContext, HttpResponse } from '@ngify/http';
+import { WX_UPLOAD_FILE_TOKEN } from '@ngify/http-wx';
+import { UploadKeys } from '@solar-kit/planets/earth';
+import { once, overlay, vibrator } from '@solar-taro/core';
+import { catchError } from 'rxjs';
+
+export class ObjectStorageService {
+  private readonly http = new HttpClient();
+
+  /**
+   * 目前只支持了 qiniu oss
+   * @param filePath
+   * @param options
+   * @returns
+   */
+  upload(filePath: string, key: string, options: Pick<UploadKeys, 'host' | 'token'>) {
+    return this.http.post<{ hash: string, key: string }>(
+      `https://${options.host}`,
+      { key: key, token: options.token },
+      {
+        context: new HttpContext().set(WX_UPLOAD_FILE_TOKEN, {
+          filePath,
+          fileName: 'file'
+        })
+      }
+    ).pipe(
+      catchError((error: HttpResponse<unknown>) => {
+        vibrator.short();
+        overlay.tips('操作失败，状态码：' + error.status || '未知');
+
+        throw error;
+      })
+    );
+  }
+}
+
+export const oss = once(() => new ObjectStorageService());

package/src/earth/service.ts

@@ -0,0 +1,105 @@
+import { HttpClient, HttpContext, withInterceptors } from '@ngify/http';
+import { Category, Channel, Origin, UploadKeys } from '@solar-kit/planets/earth';
+import { Result } from '@solar-kit/planets/sun';
+import { defineService, overlay } from '@solar-taro/core';
+import { CACHEABLE_TOKEN, useApiInterceptor, useCacheInterceptor } from '@solar-taro/http';
+import { tap } from 'rxjs';
+import { useAuthInterceptor } from '../mercury';
+
+export interface EarthConfig {
+  /** earth service host */
+  url: string;
+}
+
+export const [setupEarth, earthService] = defineService((config: EarthConfig) => new EarthService(config));
+
+export class EarthService {
+  readonly http = new HttpClient(
+    withInterceptors([
+      useApiInterceptor(),
+      useCacheInterceptor(),
+      useAuthInterceptor(),
+    ])
+  );
+
+  constructor(
+    public readonly config: EarthConfig
+  ) { }
+
+  /**
+   * 发送短信验证码
+   * @param cellphone
+   * @deprecated 使用小程序来获取手机号
+   */
+  sendSmsCode(cellphone: string | number) {
+    return this.http.get<Result>(`${this.config.url}/sms/code/${cellphone}`).pipe(
+      tap(({ code }) => code === 0 && overlay.success('发送成功'))
+    );
+  }
+
+  /**
+   * 获得信道
+   * @param origin
+   */
+  channels(origin: Origin) {
+    return this.http.get<Result<Channel[]>>(`${this.config.url}/channel/${origin}`, {
+      context: new HttpContext().set(CACHEABLE_TOKEN, true)
+    });
+  }
+
+  /**
+   * 获得品类
+   * @param origin
+   */
+  categories(origin: Origin) {
+    return this.http.get<Result<Category[]>>(`${this.config.url}/category/${origin}`, {
+      context: new HttpContext().set(CACHEABLE_TOKEN, true)
+    });
+  }
+
+  /**
+   * 加载单位
+   */
+  unitCategories() {
+    return this.categories(Origin.Unit);
+  }
+
+  /**
+   * 加载单位
+   */
+  unitChannels() {
+    return this.channels(Origin.Unit);
+  }
+
+  /**
+   * 获取 qiniu token
+   * @param bucket
+   * @deprecated {@link mediaUploadKeys}
+   */
+  qiniuToken(bucket: 0 | 1) {
+    const url = {
+      [0]: `${this.config.url}/res/upload-token`,
+      [1]: `${this.config.url}/media/upload-token`,
+    }[bucket];
+
+    return this.http.get<Result<string>>(url);
+  }
+
+  /**
+   * 获取上传头像的文件名（key）
+   * @deprecated {@link avatarUploadKey}
+   */
+  avatarKey() {
+    return this.http.get<Result<string>>(`${this.config.url}/avatar/upload-key`);
+  }
+
+  avatarUploadKey() {
+    return this.http.get<Result<UploadKeys>>(`${this.config.url}/qiniu/avatar/upload-key`);
+  }
+
+  mediaUploadKeys(keySize = 1) {
+    return this.http.get<Result<UploadKeys>>(`${this.config.url}/qiniu/media/upload-keys`, {
+      params: { keySize }
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export default void 0;

package/src/mercury/auth.interceptor.ts

@@ -0,0 +1,67 @@
+import type { HttpEvent, HttpHandlerFn, HttpInterceptorFn, HttpRequest, HttpResponse } from '@ngify/http';
+import { HttpStatusCode } from '@ngify/http';
+import { Result } from '@solar-kit/planets/sun';
+import { catchError, finalize, Observable, share, switchMap } from 'rxjs';
+import { WxAuth } from './model';
+import { mercuryService } from './service';
+
+/** 负责基础业务接口的认证 */
+export function useAuthInterceptor(): HttpInterceptorFn {
+  /** 令牌刷新器 */
+  let refresher: Observable<Result<WxAuth>> | null = null;
+
+  /**
+   * 获取访问令牌
+   */
+  function updateToken() {
+    refresher = mercuryService().auth().pipe(
+      finalize(() => refresher = null),
+      share(),
+    );
+  }
+
+  /**
+   * 等待令牌后再发送请求
+   * @param request
+   * @param next
+   */
+  function waitToken(request: HttpRequest<unknown>, next: HttpHandlerFn) {
+    return refresher!.pipe(
+      switchMap(({ data }) => (
+        next(request.clone({
+          headers: request.headers.set('Authorization', 'Bearer ' + data.token.access_token)
+        }))
+      ))
+    );
+  }
+
+  return (request: HttpRequest<unknown>, next: HttpHandlerFn): Observable<HttpEvent<unknown>> => {
+    const tokens = mercuryService().tokens;
+
+    if (!tokens?.accessToken && !refresher) {
+      updateToken();
+    }
+
+    if (refresher) {
+      return waitToken(request, next);
+    }
+
+    request = request.clone({
+      headers: request.headers.set('Authorization', 'Bearer ' + tokens.accessToken)
+    });
+
+    return next(request).pipe(
+      catchError((error: HttpResponse<unknown>) => {
+        if (error.status === HttpStatusCode.Unauthorized) {
+          if (!refresher) {
+            updateToken();
+          }
+
+          return waitToken(request, next);
+        }
+
+        throw error;
+      })
+    );
+  }
+}

package/src/mercury/index.ts

@@ -0,0 +1,2 @@
+export * from './auth.interceptor';
+export * from './service';

package/src/mercury/model.ts

@@ -0,0 +1,9 @@
+/** 用户认证 */
+export interface WxAuth {
+  openId: string;
+  token: {
+    access_token: string;
+    expires_in: number;
+    token_type: string;
+  }
+}

package/src/mercury/service.ts

@@ -0,0 +1,75 @@
+import { HttpClient, HttpResponse, HttpStatusCode, withInterceptors } from '@ngify/http';
+import { Fan } from '@solar-kit/planets/earth';
+import { AuthTokens, Result } from '@solar-kit/planets/sun';
+import { defineService } from '@solar-taro/core';
+import { useApiInterceptor, WxHeader } from '@solar-taro/http';
+import { checkSession, getStorageSync, getUserInfo, login, setStorage } from '@tarojs/taro';
+import { catchError, defer, from, map, Observable, switchMap, tap } from 'rxjs';
+import { WxAuth } from './model';
+
+export interface MercuryConfig {
+  /** mercury service host */
+  url: string;
+  app: string;
+  fan: Fan;
+}
+
+const TOKEN_STORAGE_KEY = 'auth-token';
+
+export const [setupMercury, mercuryService] = defineService((config: MercuryConfig) => new MercuryService(config));
+
+export class MercuryService {
+  protected http = new HttpClient(
+    withInterceptors([
+      useApiInterceptor()
+    ])
+  );
+
+  tokens: AuthTokens = getStorageSync<AuthTokens>(TOKEN_STORAGE_KEY) || {};
+
+  constructor(
+    protected readonly config: MercuryConfig
+  ) { }
+
+  auth(relogin = false): Observable<Result<WxAuth>> {
+    return defer(() =>
+      relogin
+        ? login()
+        : from(checkSession()).pipe(
+          map(() => ({ code: null })),
+          catchError(() => login()),
+        )
+    ).pipe(
+      switchMap(({ code }) =>
+        from(getUserInfo()).pipe(
+          map(({ encryptedData, iv }) => ({ code, encryptedData, iv }))
+        )
+      ),
+      switchMap(({ code, encryptedData, iv }) => {
+        return this.http.post<Result<WxAuth>>(`${this.config.url}/oaa/wx/auth`, null, {
+          headers: {
+            [WxHeader.Code]: code || '',
+            [WxHeader.EncryptedData]: encryptedData,
+            [WxHeader.Iv]: iv,
+            [WxHeader.App]: this.config.app,
+            [WxHeader.OpenId]: this.config.fan.openId || '',
+          }
+        });
+      }),
+      tap(({ data }) => {
+        this.tokens = { accessToken: data.token.access_token };
+        setStorage({
+          key: TOKEN_STORAGE_KEY,
+          data: this.tokens
+        });
+      }),
+      catchError((error: HttpResponse<unknown>) => {
+        if (error.status === HttpStatusCode.Unauthorized) {
+          return this.auth(true);
+        }
+        throw error;
+      })
+    );
+  }
+
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,24 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx"
+  ]
+}

package/tsconfig.spec.json

@@ -0,0 +1,28 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "types": [
+      "vitest/globals",
+      "vitest/importMeta",
+      "vite/client",
+      "node",
+      "vitest"
+    ]
+  },
+  "include": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts"
+  ]
+}

package/typedoc.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://typedoc.org/schema.json",
+  "entryPoints": [
+    "src/earth/index.ts",
+    "src/mercury/index.ts"
+  ]
+}

package/vite.config.ts

@@ -0,0 +1,24 @@
+import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  root: __dirname,
+  cacheDir: '../../node_modules/.vite/planets',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  // Uncomment this if you are using workers.
+  // worker: {
+  //  plugins: [ nxViteTsPaths() ],
+  // },
+  test: {
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '../../coverage/planets',
+      provider: 'v8',
+    },
+  },
+});