@darco2903/cdn-api 1.0.7-beta.0

package/src/types/endpoint.ts

@@ -0,0 +1,19 @@
+import z from "zod";
+
+export const endpointPathSchema = z
+    .string()
+    .max(256)
+    .regex(/^(\/[a-zA-Z0-9]+([_.-][a-zA-Z0-9]+)*)*$/, "Invalid endpoint");
+
+export const endpointPublicSchema = z.object({
+    endpoint: endpointPathSchema,
+});
+
+export type EndpointPublic = z.infer<typeof endpointPublicSchema>;
+
+export const endpointSchema = endpointPublicSchema.extend({
+    created_at: z.coerce.date(),
+    updated_at: z.coerce.date(),
+});
+
+export type Endpoint = z.infer<typeof endpointSchema>;

package/src/types/index.ts

@@ -0,0 +1,6 @@
+export * from "./creds.js";
+export * from "./endpoint.js";
+export * from "./jwt.js";
+export * from "./record.js";
+export * from "./stats.js";
+export * from "./upload.js";

package/src/types/jwt.ts

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

@@ -0,0 +1,35 @@
+import z from "zod";
+import { userPublicIdSchema } from "@darco2903/auth-api/client";
+import { endpointPublicSchema, endpointSchema } from "./endpoint.js";
+import { STORAGE_PUBLIC_ID_LENGTH } from "../consts.js";
+
+export const storagePublicIdSchema = z
+    .string()
+    .length(STORAGE_PUBLIC_ID_LENGTH);
+
+export const recordPublicSchema = z.object({
+    storage_id: storagePublicIdSchema,
+    filename: z.string(),
+    size: z.number().int().gte(0),
+    mime_type: z.string(),
+    endpoints: z.array(endpointPublicSchema),
+});
+
+export type RecordPublic = z.infer<typeof recordPublicSchema>;
+
+export const recordTypeSchema = z.enum(["service", "system", "user"]);
+
+export type RecordType = z.infer<typeof recordTypeSchema>;
+
+export const recordSchema = recordPublicSchema.extend({
+    endpoints: z.array(endpointSchema),
+    role: z.number().int().min(-1).max(255),
+    user_id: userPublicIdSchema.nullable(),
+    type: recordTypeSchema,
+    visible: z.boolean(),
+    active: z.boolean(),
+    created_at: z.coerce.date(),
+    updated_at: z.coerce.date(),
+});
+
+export type Record = z.infer<typeof recordSchema>;

package/src/types/stats.ts

@@ -0,0 +1,9 @@
+import z from "zod";
+
+export const statsGlobalSchema = z.object({
+    record_count: z.number().int().gte(0),
+    total_size: z.number().int().gte(0),
+    max_size: z.number().int().gte(0),
+});
+
+export type StatsGlobal = z.infer<typeof statsGlobalSchema>;

package/src/types/upload.ts

@@ -0,0 +1,18 @@
+import z from "zod";
+
+export const uploadDataSchema = z.object({
+    filename: z.string().min(3).max(100),
+    role: z.number().int().min(0).max(255),
+    visible: z.boolean(),
+    active: z.boolean(),
+});
+
+export type UploadData = z.infer<typeof uploadDataSchema>;
+
+export const uploadInitSchema = uploadDataSchema.extend({
+    size: z.number().int().min(1),
+    mimeType: z.string().min(3).max(100),
+    parts: z.number().int().min(1),
+});
+
+export type UploadInit = z.infer<typeof uploadInitSchema>;

package/src/types.ts

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

@@ -0,0 +1,99 @@
+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");
+            }
+        }
+    }
+}

package/tests/keys/private.pem

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

package/tests/keys/public.pem

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

package/tests/keys.ts

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,12 @@
+{
+  "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

@@ -0,0 +1,38 @@
+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/tools/generate-openapi.ts

@@ -0,0 +1,25 @@
+import fs from "fs";
+import { generateOpenApi } from "@ts-rest/open-api";
+import { contract } from "../src/";
+
+import { version } from "../package.json";
+
+console.log("Generating OpenAPI documentation...");
+console.log(`API version: ${version}`);
+
+const openApiDocument = generateOpenApi(contract, {
+    info: {
+        title: "CDN API",
+        version,
+    },
+    servers: [
+        {
+            url: "https://cdn.darco2903.fr",
+        },
+        {
+            url: "https://dev-cdn.darco2903.fr",
+        },
+    ],
+});
+
+fs.writeFileSync("openapi.json", JSON.stringify(openApiDocument, null, 2));

package/tsconfig.json

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