@darco2903/cdn-api 1.0.7-beta.0 → 1.0.7-beta.1

package/{src/uploader.ts → dist/uploader.js}

@@ -1,99 +1,72 @@
-import axios, { AxiosInstance } from "axios";
-import type { UploadData } from "./types/upload.js";
-import { createClient } from "./client.js";
-
-export default class Uploader {
-    static MAX_SINGLE_UPLOAD_SIZE = 100_000_000; // 100MB
-
-    protected ax: AxiosInstance;
-    protected client;
-
-    constructor(origin: string) {
-        this.ax = axios.create({
-            baseURL: origin,
-            withCredentials: true,
-        });
-        this.client = createClient(origin);
-    }
-
-    protected getPartEndpoint(uploadId: string, part: number) {
-        return `/upload/part/${uploadId}/${part}`;
-    }
-
-    public async upload(
-        file: File,
-        role: number,
-        visible: boolean,
-        active: boolean
-    ) {
-        if (file.size < Uploader.MAX_SINGLE_UPLOAD_SIZE) {
-            const formData = new FormData();
-            const data: UploadData = {
-                filename: file.name,
-                role,
-                visible,
-                active,
-            };
-            formData.append("data", JSON.stringify(data));
-            formData.append("file", file);
-            const res = await this.ax.post("/upload", formData, {
-                onUploadProgress(e) {
-                    //
-                },
-            });
-        } else {
-            const parts = Math.ceil(
-                file.size / Uploader.MAX_SINGLE_UPLOAD_SIZE
-            );
-            const resInit = await this.client.upload.uploadInit({
-                body: {
-                    filename: file.name,
-                    role,
-                    visible,
-                    active,
-                    size: file.size,
-                    mimeType: file.type,
-                    parts,
-                },
-            });
-
-            if (resInit.status !== 200) {
-                throw new Error("Failed to initialize upload");
-            }
-
-            const uploadId = resInit.body.uploadId;
-
-            for (let part = 0; part < parts; part++) {
-                const start = part * Uploader.MAX_SINGLE_UPLOAD_SIZE;
-                const end = Math.min(
-                    start + Uploader.MAX_SINGLE_UPLOAD_SIZE,
-                    file.size
-                );
-
-                const formData = new FormData();
-                formData.append("file", file.slice(start, end));
-
-                const res = await this.ax.post(
-                    this.getPartEndpoint(uploadId, part + 1),
-                    formData,
-                    {
-                        onUploadProgress(e) {
-                            //
-                        },
-                    }
-                );
-
-                if (res.status !== 200) {
-                    throw new Error("Failed to upload part " + (part + 1));
-                }
-            }
-
-            const res = await this.client.upload.uploadEnd({
-                params: { upload_id: uploadId },
-            });
-            if (res.status !== 200) {
-                throw new Error("Failed to finalize upload");
-            }
-        }
-    }
-}
+import axios from "axios";
+import { createClient } from "./client.js";
+class Uploader {
+    constructor(origin) {
+        this.ax = axios.create({
+            baseURL: origin,
+            withCredentials: true,
+        });
+        this.client = createClient(origin);
+    }
+    getPartEndpoint(uploadId, part) {
+        return `/upload/part/${uploadId}/${part}`;
+    }
+    async upload(file, role, visible, active) {
+        if (file.size < Uploader.MAX_SINGLE_UPLOAD_SIZE) {
+            const formData = new FormData();
+            const data = {
+                filename: file.name,
+                role,
+                visible,
+                active,
+            };
+            formData.append("data", JSON.stringify(data));
+            formData.append("file", file);
+            const res = await this.ax.post("/upload", formData, {
+                onUploadProgress(e) {
+                    //
+                },
+            });
+        }
+        else {
+            const parts = Math.ceil(file.size / Uploader.MAX_SINGLE_UPLOAD_SIZE);
+            const resInit = await this.client.upload.uploadInit({
+                body: {
+                    filename: file.name,
+                    role,
+                    visible,
+                    active,
+                    size: file.size,
+                    mimeType: file.type,
+                    parts,
+                },
+            });
+            if (resInit.status !== 200) {
+                throw new Error("Failed to initialize upload");
+            }
+            const uploadId = resInit.body.uploadId;
+            for (let part = 0; part < parts; part++) {
+                const start = part * Uploader.MAX_SINGLE_UPLOAD_SIZE;
+                const end = Math.min(start + Uploader.MAX_SINGLE_UPLOAD_SIZE, file.size);
+                const formData = new FormData();
+                formData.append("file", file.slice(start, end));
+                const res = await this.ax.post(this.getPartEndpoint(uploadId, part + 1), formData, {
+                    onUploadProgress(e) {
+                        //
+                    },
+                });
+                if (res.status !== 200) {
+                    throw new Error("Failed to upload part " + (part + 1));
+                }
+            }
+            const res = await this.client.upload.uploadEnd({
+                params: { upload_id: uploadId },
+            });
+            if (res.status !== 200) {
+                throw new Error("Failed to finalize upload");
+            }
+        }
+    }
+}
+Uploader.MAX_SINGLE_UPLOAD_SIZE = 100000000; // 100MB
+export default Uploader;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darco2903/cdn-api",
-  "version": "1.0.7-beta.0",
+  "version": "1.0.7-beta.1",
   "description": "",
   "main": "./dist/index.js",
   "type": "module",
@@ -19,7 +19,7 @@
     "./server": "./dist/server.js"
   },
   "dependencies": {
-    "@darco2903/auth-api": "2.0.3-pre.0",
+    "@darco2903/auth-api": "2.1.0",
     "@ts-rest/core": "^3.52.1",
     "@ts-rest/open-api": "^3.52.1",
     "axios": "^1.12.2",

package/.gitattributes

@@ -1,2 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto

package/.github/workflows/release.yml

@@ -1,116 +0,0 @@
-name: Release
-
-on:
-  push:
-    tags:
-      - "v*" # Trigger on version tags
-
-permissions:
-  id-token: write
-  contents: write
-
-env:
-  PNPM_VERSION: "10.32.0"
-  TARBALL_NAME: "darco2903-cdn-api"
-
-jobs:
-  check:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v5
-
-      - name: Check tag matches package.json version
-        run: |
-          TAG_VERSION="${GITHUB_REF_NAME#v}"
-          PKG_VERSION=$(node -p "require('./package.json').version")
-          PNPM_VERSION=$(node -p "require('./package.json').packageManager.split('@')[1]")
-
-          echo "Tag version: $TAG_VERSION"
-          echo "Package version: $PKG_VERSION"
-
-          if [ "$TAG_VERSION" != "$PKG_VERSION" ]; then
-            echo "❌ Tag version does not match package.json version"
-            exit 1
-          fi
-
-          if [ "$PNPM_VERSION" != "${{ env.PNPM_VERSION }}" ]; then
-            echo "❌ package.json specifies pnpm version $PNPM_VERSION, expected ${{ env.PNPM_VERSION }}"
-            exit 1
-          fi
-
-  #
-
-  test:
-    needs: check
-    runs-on: ${{ matrix.os }}
-
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
-        node-version: [24]
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v5
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: "${{ env.PNPM_VERSION }}"
-
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-          cache: "pnpm"
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Run tests
-        run: pnpm test
-
-  #
-
-  release:
-    needs: [check, test]
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [24]
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v5
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: "${{ env.PNPM_VERSION }}"
-
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-          cache: "pnpm"
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Pack project
-        run: pnpm pack
-
-      - name: Upload release asset
-        uses: softprops/action-gh-release@v2
-        with:
-          files: "${{ env.TARBALL_NAME }}-*.tgz"
-          generate_release_notes: true
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Publish to NPM
-        shell: bash
-        run: pnpm publish --access public --no-git-checks

package/prettier.config.js

@@ -1,24 +0,0 @@
-/**
- * @see https://prettier.io/docs/configuration
- * @type {import("prettier").Config}
- */
-const config = {
-    trailingComma: "es5",
-    tabWidth: 4,
-    semi: true,
-    singleQuote: false,
-    bracketSpacing: true,
-    printWidth: 80,
-    arrowParens: "always",
-    endOfLine: "lf",
-    useTabs: false,
-    proseWrap: "preserve",
-    quoteProps: "as-needed",
-    htmlWhitespaceSensitivity: "css",
-    bracketSameLine: false,
-    experimentalOperatorPosition: "start",
-    experimentalTernaries: true,
-    objectWrap: "preserve",
-};
-
-export default config;

package/src/server.ts

@@ -1,89 +0,0 @@
-export * from "./common.js";
-import jwt from "jsonwebtoken";
-import { ResultAsync } from "neverthrow";
-import type { Time } from "@darco2903/secondthought";
-import {
-    cdnAssetTokenDataDecodedSchema,
-    type JWTVerifyError,
-    type CdnFeedbackTokenData,
-    type CdnAssetTokenDataDecoded,
-    type JWTSignError,
-} from "./common.js";
-import { JWT_ALGORITHM } from "./consts.js";
-
-export function JWTVerify(
-    token: string,
-    pubKey: string
-): ResultAsync<CdnAssetTokenDataDecoded, JWTVerifyError> {
-    return ResultAsync.fromPromise(
-        new Promise((resolve, reject) => {
-            jwt.verify(
-                token,
-                pubKey,
-                { algorithms: [JWT_ALGORITHM] },
-                (e, decoded) => {
-                    if (e) {
-                        reject({
-                            name: e.name as JWTVerifyError["name"],
-                            message: e.message,
-                        } satisfies JWTVerifyError);
-                    } else if (decoded === undefined) {
-                        reject({
-                            name: "InvalidToken",
-                            message: "Token is undefined",
-                        } satisfies JWTVerifyError);
-                    } else {
-                        const res =
-                            cdnAssetTokenDataDecodedSchema.safeParse(decoded);
-                        if (res.success) {
-                            resolve(res.data);
-                        } else {
-                            reject({
-                                name: "InvalidTokenData",
-                                message: "Invalid token data",
-                            } satisfies JWTVerifyError);
-                        }
-                    }
-                }
-            );
-        }),
-        (e) => e as JWTVerifyError
-    );
-}
-
-/**
- * Sign a JWT token with the given payload and private key, with the specified expiration time.
- * @param expiresIn Expiration time in seconds or a Time object.
- */
-export function JWTSign(
-    payload: CdnFeedbackTokenData,
-    privKey: string,
-    expiresIn: number | Time
-): ResultAsync<string, JWTSignError> {
-    const expiresInSec =
-        typeof expiresIn === "number" ? expiresIn : expiresIn.toSecond().time;
-
-    return ResultAsync.fromPromise(
-        new Promise((resolve, reject) => {
-            jwt.sign(
-                payload,
-                privKey,
-                {
-                    algorithm: JWT_ALGORITHM,
-                    expiresIn: expiresInSec,
-                },
-                (e, token) => {
-                    if (e || token === undefined) {
-                        reject({
-                            name: "JsonWebTokenError",
-                            message: e?.message ?? "Failed to sign token",
-                        } satisfies JWTSignError);
-                    } else {
-                        resolve(token);
-                    }
-                }
-            );
-        }),
-        (e) => e as JWTSignError
-    );
-}

package/src/socket/interface/index.ts

@@ -1,12 +0,0 @@
-import {
-    SocketClientToServerTemplate,
-    SocketServerToClientTemplate,
-} from "./template.js";
-
-export interface CdnClientToServerEvents
-    //
-    extends SocketClientToServerTemplate {}
-
-export interface CdnServerToClientEvents
-    //
-    extends SocketServerToClientTemplate {}

package/src/socket/types.ts

@@ -1,7 +0,0 @@
-import type { Socket as ClientSocket } from "socket.io-client";
-import {
-    CdnClientToServerEvents as ClientToServer,
-    CdnServerToClientEvents as ServerToClient,
-} from "./interface/index.js";
-
-export type CdnClientSocket = ClientSocket<ServerToClient, ClientToServer>;

package/src/types/jwt.ts

@@ -1,78 +0,0 @@
-import z from "zod";
-import {
-    authAssetTypeSchema,
-    authServiceSchema,
-    userPublicIdSchema,
-} from "@darco2903/auth-api/client";
-import { endpointPathSchema } from "./endpoint.js";
-
-export type JWTVerifyError = {
-    name:
-        | "TokenExpiredError"
-        | "JsonWebTokenError"
-        | "NotBeforeError"
-        | "InvalidToken"
-        | "InvalidTokenData";
-    message: string;
-};
-
-export type JWTSignError = {
-    name: "InvalidTokenData" | "JsonWebTokenError";
-    message: string;
-};
-
-const JWTData = z.object({
-    iat: z.number(),
-    exp: z.number(),
-});
-
-export const jwtSchema = z.string().startsWith("Bearer ");
-
-///////////////////////////////////
-
-export const cdnAssetHeaderSchema = z.object({
-    "x-cdn-asset": jwtSchema.optional(),
-});
-
-export const cdnAssetTokenDataSchema = z.object({
-    service: authServiceSchema,
-    type: z.literal("avatar"),
-    endpoint: endpointPathSchema,
-    user_public_id: userPublicIdSchema,
-    file_size_max: z.number().min(0).optional(),
-    allowed_file_types: z.array(z.string()).optional(),
-    callback_url: z.string().url().optional(),
-});
-
-export const cdnAssetTokenDataDecodedSchema = z.intersection(
-    cdnAssetTokenDataSchema,
-    JWTData
-);
-
-export type CdnAssetTokenData = z.infer<typeof cdnAssetTokenDataSchema>;
-export type CdnAssetTokenDataDecoded = z.infer<
-    typeof cdnAssetTokenDataDecodedSchema
->;
-
-///////////////////////////////////
-
-export const cdnFeedbackHeaderSchema = z.object({
-    authorization: jwtSchema.optional(),
-});
-
-export const cdnFeedbackTokenDataSchema = z.object({
-    service: authServiceSchema,
-    type: authAssetTypeSchema,
-    endpoint: endpointPathSchema,
-    user_public_id: userPublicIdSchema,
-});
-
-export const cdnFeedbackTokenDecodedSchema = z.intersection(
-    cdnFeedbackTokenDataSchema,
-    JWTData
-);
-
-export type CdnFeedbackTokenData = z.infer<typeof cdnFeedbackTokenDataSchema>;
-export type CdnFeedbackTokenDataDecoded = z.infer<
-    typeof cdnFeedbackTokenDecodedSchema
->;

package/src/types.ts

@@ -1,38 +0,0 @@
-import { z, type ZodType } from "zod";
-
-export const apiSuccess = <T>(schema: ZodType<T>) => schema;
-
-export const apiError = <T, U>(code: ZodType<T>, error: ZodType<U>) =>
-    z.object({
-        code,
-        error,
-        name: z.literal("APIError"),
-    });
-
-export const apiErrorData = <T, U, V>(
-    code: ZodType<T>,
-    error: ZodType<U>,
-    data: ZodType<V>
-) =>
-    z.object({
-        code,
-        error,
-        name: z.literal("APIError"),
-        data,
-    });
-
-export function jsonStringAs<T extends z.ZodTypeAny>(
-    schema: T
-): z.ZodEffects<z.ZodString, z.infer<T>> {
-    return z.string().transform((str, ctx) => {
-        try {
-            return schema.parse(JSON.parse(str));
-        } catch {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: "Invalid JSON",
-            });
-            return z.NEVER;
-        }
-    });
-}

package/tests/keys/private.pem

@@ -1,5 +0,0 @@
------BEGIN EC PRIVATE KEY-----
-MHcCAQEEIGqV6t//MTxzvRRH46iJbu2zzeOUFOjmF8JQs75lYb61oAoGCCqGSM49
-AwEHoUQDQgAE9MaRmiwH25Dv6y1wKrcEGMCG1EUB9s3zZlxIXsOR7EI5xaTMdedb
-2J7IDmTacZDD0ZCJ7DSyrS88mcTztm+kWQ==
------END EC PRIVATE KEY-----

package/tests/keys/public.pem

@@ -1,4 +0,0 @@
------BEGIN PUBLIC KEY-----
-MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9MaRmiwH25Dv6y1wKrcEGMCG1EUB
-9s3zZlxIXsOR7EI5xaTMdedb2J7IDmTacZDD0ZCJ7DSyrS88mcTztm+kWQ==
------END PUBLIC KEY-----

package/tests/keys.ts

@@ -1,11 +0,0 @@
-import fs from "fs";
-import path from "path";
-
-export const PRIVATE_KEY = fs.readFileSync(
-    path.join(import.meta.dirname, "keys/private.pem"),
-    "utf-8"
-);
-export const PUBLIC_KEY = fs.readFileSync(
-    path.join(import.meta.dirname, "keys/public.pem"),
-    "utf-8"
-);

package/tests/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true,
-    "rootDir": "..",
-    "types": ["node"],
-    "module": "nodenext",
-    "moduleResolution": "nodenext"
-  },
-  "include": ["**/*.ts", "../src/**/*.ts"],
-  "exclude": ["../dist", "../node_modules"]
-}

package/tests/vitest/jwt.test.ts

@@ -1,38 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-    type CdnFeedbackTokenData,
-    JWTSign,
-    JWTVerify,
-} from "../../src/index.js";
-import { Hour } from "@darco2903/secondthought";
-import { PRIVATE_KEY, PUBLIC_KEY } from "../keys.js";
-
-//////////////////////////
-// Tests for JWT Sign & Verify
-
-describe("JWT Sign & Verify", () => {
-    it("should resolve after the specified time", async () => {
-        const data: CdnFeedbackTokenData = {
-            user_public_id: "abcdefgh",
-            endpoint: "/test",
-            service: "auth",
-            type: "avatar",
-        };
-
-        const res = await JWTSign(data, PRIVATE_KEY, new Hour(1));
-        expect(res.isOk()).toBeTruthy();
-
-        const signedToken = res._unsafeUnwrap();
-        expect(signedToken).toBeTypeOf("string");
-
-        const verifyRes = await JWTVerify(signedToken, PUBLIC_KEY);
-        expect(verifyRes.isOk()).toBeTruthy();
-
-        const decodedData = verifyRes._unsafeUnwrap();
-        expect(decodedData).toMatchObject({
-            ...data,
-            iat: expect.any(Number),
-            exp: expect.any(Number),
-        });
-    });
-});

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-    "compilerOptions": {
-        "declaration": true,
-        "target": "ES2020",
-        "module": "nodenext",
-        "outDir": "dist",
-        "rootDir": "src",
-        "esModuleInterop": true,
-        "strict": true,
-        "moduleResolution": "node16",
-        "resolveJsonModule": true
-    },
-    "include": ["src"]
-}