@darco2903/cdn-api 1.0.7-beta.0

package/README.md

@@ -0,0 +1,25 @@
+# CDN API
+
+## Description
+
+This API is a TypeScript client for the Darco2903 CDN service.
+
+## Installation
+
+```bash
+npm install cdn-api-<version>.tgz
+npm install @ts-rest/core zod@3.22.3
+```
+
+## Usage
+
+Create an instance of the API
+
+```ts
+import { initClient } from "@ts-rest/core";
+import { contract } from "cdn-api";
+
+const api = initClient(contract, {
+    baseUrl: "https://api.example.com",
+});
+```

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@darco2903/cdn-api",
+  "version": "1.0.7-beta.0",
+  "description": "",
+  "main": "./dist/index.js",
+  "type": "module",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "repository": {
+    "url": "https://github.com/Darco2903/cdn-api.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./client": "./dist/client.js",
+    "./server": "./dist/server.js"
+  },
+  "dependencies": {
+    "@darco2903/auth-api": "2.0.3-pre.0",
+    "@ts-rest/core": "^3.52.1",
+    "@ts-rest/open-api": "^3.52.1",
+    "axios": "^1.12.2",
+    "jsonwebtoken": "^9.0.3",
+    "neverthrow": "^8.2.0",
+    "socket.io-client": "^4.8.1",
+    "zod": "^3.25.76"
+  },
+  "peerDependencies": {
+    "@darco2903/secondthought": "^1.1.0"
+  },
+  "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/node": "^25.4.0",
+    "prettier": "^3.8.1",
+    "rimraf": "^6.1.3",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest",
+    "clean": "rimraf -g dist darco2903-cdn-api-*.tgz openapi.json",
+    "generate:openapi": "tsx tools/generate-openapi.ts"
+  }
+}

package/prettier.config.js

@@ -0,0 +1,24 @@
+/**
+ * @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/client.ts

@@ -0,0 +1,18 @@
+export * from "./common.js";
+import io from "socket.io-client";
+import { initClient } from "@ts-rest/core";
+import contract from "./contract/index.js";
+import type { CdnClientSocket } from "./socket/index.js";
+
+export function createClient(origin: string) {
+    return initClient(contract, {
+        baseUrl: origin,
+        credentials: "include",
+    });
+}
+
+export function createSocket(origin: string): CdnClientSocket {
+    return io(origin, {
+        autoConnect: true,
+    });
+}

package/src/common.ts

@@ -0,0 +1,4 @@
+export { default as contract } from "./contract/index.js";
+export * from "./socket/index.js";
+export * from "./types/index.js";
+export * from "./consts.js";

package/src/consts.ts

@@ -0,0 +1,8 @@
+import type { Algorithm } from "jsonwebtoken";
+
+export const API_VERSION = "v2";
+export const API_PATH_PREFIX = `/api/${API_VERSION}`;
+
+export const JWT_ALGORITHM: Algorithm = "ES256";
+
+export const STORAGE_PUBLIC_ID_LENGTH = 8;

package/src/contract/auth.ts

@@ -0,0 +1,22 @@
+import { initContract } from "@ts-rest/core";
+import z from "zod";
+import { authHeaderSchema } from "@darco2903/auth-api/client";
+import { apiError, apiSuccess } from "../types.js";
+
+const c = initContract();
+
+export default c.router({
+    access: {
+        method: "GET",
+        path: "/auth/access",
+        headers: authHeaderSchema,
+        responses: {
+            200: apiSuccess(
+                z.object({
+                    access: z.boolean(),
+                })
+            ),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+});

package/src/contract/endpoint.ts

@@ -0,0 +1,53 @@
+import { initContract, ZodErrorSchema } from "@ts-rest/core";
+import z from "zod";
+import { authHeaderSchema } from "@darco2903/auth-api/client";
+import { apiError, apiSuccess } from "../types.js";
+import { endpointPathSchema } from "../types/index.js";
+
+const c = initContract();
+
+export default c.router({
+    create: {
+        method: "POST",
+        path: "/endpoint",
+        headers: authHeaderSchema,
+        body: z.object({
+            storage_id: z.string().nonempty(),
+            endpoint: endpointPathSchema,
+        }),
+        responses: {
+            200: apiSuccess(z.null()),
+            400: ZodErrorSchema,
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            403: apiError(z.literal("FORBIDDEN"), z.literal("Forbidden")),
+            404: apiError(
+                z.literal("NOT_FOUND"),
+                z.literal("Record not found")
+            ),
+            409: apiError(
+                z.literal("CONFLICT"),
+                z.literal("Endpoint already exists")
+            ),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    delete: {
+        method: "DELETE",
+        path: "/endpoint",
+        headers: authHeaderSchema,
+        body: z.object({
+            endpoint: endpointPathSchema,
+        }),
+        responses: {
+            200: apiSuccess(z.null()),
+            400: ZodErrorSchema,
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            403: apiError(z.literal("FORBIDDEN"), z.literal("Forbidden")),
+            404: apiError(
+                z.literal("NOT_FOUND"),
+                z.literal("Endpoint not found")
+            ),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+});

package/src/contract/index.ts

@@ -0,0 +1,27 @@
+import { initContract } from "@ts-rest/core";
+import auth from "./auth.js";
+import endpoint from "./endpoint.js";
+import key from "./key.js";
+import list from "./list.js";
+import record from "./record.js";
+import service from "./service.js";
+import stats from "./stats.js";
+import upload from "./upload.js";
+
+const c = initContract();
+
+export default c.router(
+    {
+        auth,
+        endpoint,
+        ...key,
+        list,
+        record,
+        service,
+        stats,
+        upload,
+    },
+    {
+        pathPrefix: "/api/v2",
+    }
+);

package/src/contract/key.ts

@@ -0,0 +1,19 @@
+import { initContract } from "@ts-rest/core";
+import z from "zod";
+import { apiSuccess } from "../types.js";
+
+const c = initContract();
+
+export default c.router({
+    publicKey: {
+        method: "GET",
+        path: "/public-key",
+        responses: {
+            200: apiSuccess(
+                z.object({
+                    publicKey: z.string(),
+                })
+            ),
+        },
+    },
+});

package/src/contract/list.ts

@@ -0,0 +1,30 @@
+import { initContract } from "@ts-rest/core";
+import z from "zod";
+import { authHeaderSchema } from "@darco2903/auth-api/client";
+import { apiError, apiSuccess } from "../types.js";
+import { recordSchema, recordPublicSchema } from "../types/index.js";
+
+const c = initContract();
+
+export default c.router({
+    public: {
+        method: "GET",
+        path: "/list",
+        headers: authHeaderSchema,
+        responses: {
+            200: apiSuccess(z.array(recordPublicSchema)),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    admin: {
+        method: "GET",
+        path: "/list/admin",
+        headers: authHeaderSchema,
+        responses: {
+            200: apiSuccess(z.array(recordSchema)),
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            403: apiError(z.literal("FORBIDDEN"), z.literal("Forbidden")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+});

package/src/contract/record.ts

@@ -0,0 +1,82 @@
+import { initContract, ZodErrorSchema } from "@ts-rest/core";
+import z from "zod";
+import { authHeaderSchema } from "@darco2903/auth-api/client";
+import { apiError, apiSuccess } from "../types.js";
+import { recordSchema } from "../types/index.js";
+
+const c = initContract();
+
+export default c.router({
+    get: {
+        method: "GET",
+        path: "/record/:storage_id",
+        headers: authHeaderSchema,
+        responses: {
+            200: apiSuccess(recordSchema),
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            403: apiError(z.literal("FORBIDDEN"), z.literal("Forbidden")),
+            404: apiError(
+                z.literal("NOT_FOUND"),
+                z.literal("Record not found")
+            ),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    update: {
+        method: "POST",
+        path: "/record/:storage_id",
+        headers: authHeaderSchema,
+        body: z.union([
+            z.object({
+                filename: z.string().max(128),
+                role: z.number().gte(0).optional(),
+                active: z.boolean().optional(),
+                visible: z.boolean().optional(),
+            }),
+            z.object({
+                filename: z.string().max(128).optional(),
+                role: z.number().gte(0),
+                active: z.boolean().optional(),
+                visible: z.boolean().optional(),
+            }),
+            z.object({
+                filename: z.string().max(128).optional(),
+                role: z.number().gte(0).optional(),
+                active: z.boolean(),
+                visible: z.boolean().optional(),
+            }),
+            z.object({
+                filename: z.string().max(128).optional(),
+                role: z.number().gte(0).optional(),
+                active: z.boolean().optional(),
+                visible: z.boolean(),
+            }),
+        ]),
+        responses: {
+            200: apiSuccess(z.null()),
+            400: ZodErrorSchema,
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            403: apiError(z.literal("FORBIDDEN"), z.literal("Forbidden")),
+            404: apiError(
+                z.literal("NOT_FOUND"),
+                z.literal("Record not found")
+            ),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    delete: {
+        method: "DELETE",
+        path: "/record/:storage_id",
+        headers: authHeaderSchema,
+        responses: {
+            200: apiSuccess(z.null()),
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            403: apiError(z.literal("FORBIDDEN"), z.literal("Forbidden")),
+            404: apiError(
+                z.literal("NOT_FOUND"),
+                z.literal("Record not found")
+            ),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+});

package/src/contract/service.ts

@@ -0,0 +1,44 @@
+import { initContract, ZodErrorSchema } from "@ts-rest/core";
+import z from "zod";
+import { apiError, apiSuccess } from "../types.js";
+import { cdnHeaderSchema } from "../types/index.js";
+
+const c = initContract();
+
+export default c.router({
+    update: {
+        method: "POST",
+        path: "/service/asset",
+        headers: cdnHeaderSchema,
+        contentType: "multipart/form-data",
+        body: z.object({}),
+        responses: {
+            200: apiSuccess(z.null()),
+            400: apiError(z.literal("BAD_REQUEST"), z.string()),
+            401: apiError(
+                z.literal("UNAUTHORIZED"),
+                z.literal("Invalid CDN token")
+            ),
+            429: apiError(z.literal("TOO_MANY_REQUESTS"), z.string()),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    delete: {
+        method: "DELETE",
+        path: "/service/asset",
+        headers: cdnHeaderSchema,
+        responses: {
+            200: apiSuccess(z.null()),
+            400: ZodErrorSchema,
+            401: apiError(
+                z.literal("UNAUTHORIZED"),
+                z.literal("Invalid CDN token")
+            ),
+            404: apiError(
+                z.literal("NOT_FOUND"),
+                z.literal("Service asset not found")
+            ),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+});

package/src/contract/stats.ts

@@ -0,0 +1,36 @@
+import { initContract } from "@ts-rest/core";
+import z from "zod";
+import { apiError, apiSuccess } from "../types.js";
+import { statsGlobalSchema } from "../types/index.js";
+
+const c = initContract();
+
+export default c.router({
+    global: {
+        method: "GET",
+        path: "/stats",
+        responses: {
+            200: apiSuccess(statsGlobalSchema),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    // globalAdmin: {
+    //     method: "GET",
+    //     path: "/stats/admin",
+    //     responses: {
+    //         200: apiSuccess(statsGlobalSchema),
+    //         401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+    //         403: apiError(z.literal("FORBIDDEN"), z.literal("Forbidden")),
+    //         500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+    //     },
+    // },
+    // user: {
+    //     method: "GET",
+    //     path: "/stats/:public_id",
+    //     headers: authHeaderSchema,
+    //     responses: {
+    //         200: apiSuccess(statsGlobalSchema),
+    //         500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+    //     },
+    // },
+});

package/src/contract/upload.ts

@@ -0,0 +1,82 @@
+import { initContract, ZodErrorSchema } from "@ts-rest/core";
+import z from "zod";
+import { authHeaderSchema } from "@darco2903/auth-api/client";
+import { apiError, apiSuccess, jsonStringAs } from "../types.js";
+import { uploadDataSchema, uploadInitSchema } from "../types/index.js";
+
+const c = initContract();
+
+export default c.router({
+    upload: {
+        method: "POST",
+        path: "/upload",
+        headers: authHeaderSchema,
+        contentType: "multipart/form-data",
+        body: z.object({
+            file: z.any(),
+            data: jsonStringAs(uploadDataSchema),
+        }),
+        responses: {
+            200: apiSuccess(z.null()),
+            400: z.union([
+                ZodErrorSchema,
+                apiError(z.literal("BAD_REQUEST"), z.string()),
+            ]),
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            403: apiError(z.literal("FORBIDDEN"), z.literal("Forbidden")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    uploadInit: {
+        method: "POST",
+        path: "/upload/init",
+        body: uploadInitSchema,
+        responses: {
+            200: apiSuccess(
+                z.object({
+                    uploadId: z.string(),
+                })
+            ),
+            400: z.union([
+                ZodErrorSchema,
+                apiError(z.literal("BAD_REQUEST"), z.string()),
+            ]),
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            403: apiError(z.literal("FORBIDDEN"), z.literal("Forbidden")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    uploadPart: {
+        method: "POST",
+        path: "/upload/part/:upload_id/:part",
+        contentType: "multipart/form-data",
+        body: z.object({
+            file: z.any(),
+        }),
+        responses: {
+            200: apiSuccess(z.null()),
+            400: z.union([
+                ZodErrorSchema,
+                apiError(z.literal("BAD_REQUEST"), z.string()),
+            ]),
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            403: apiError(z.literal("FORBIDDEN"), z.literal("Forbidden")),
+            404: apiError(z.literal("NOT_FOUND"), z.string()),
+            409: apiError(z.literal("CONFLICT"), z.string()),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    uploadEnd: {
+        method: "POST",
+        path: "/upload/end/:upload_id",
+        body: z.undefined(),
+        responses: {
+            200: apiSuccess(z.null()),
+            400: ZodErrorSchema,
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            403: apiError(z.literal("FORBIDDEN"), z.literal("Forbidden")),
+            404: apiError(z.literal("NOT_FOUND"), z.string()),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+});

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./client.js";
+export * from "./server.js";

package/src/server.ts

@@ -0,0 +1,89 @@
+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/index.ts

@@ -0,0 +1,2 @@
+export * from "./interface/index.js";
+export * from "./types.js";

package/src/socket/interface/index.ts

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

package/src/socket/interface/template.ts

@@ -0,0 +1,7 @@
+export interface SocketClientToServerTemplate {
+    ping: (message: string, callback: (message: string) => void) => void;
+}
+
+export interface SocketServerToClientTemplate {
+    pong: (message: string) => void;
+}

package/src/socket/types.ts

@@ -0,0 +1,7 @@
+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/creds.ts

@@ -0,0 +1,7 @@
+import z from "zod";
+
+const jwtSchema = z.string().startsWith("Bearer ");
+
+export const cdnHeaderSchema = z.object({
+    authorization: jwtSchema,
+});