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

package/{src/contract/upload.ts → dist/contract/upload.js}

@@ -1,82 +1,78 @@
-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()),
-        },
-    },
-});
+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 → dist/index.d.ts}

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

package/dist/index.js

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

package/dist/server.d.ts

@@ -0,0 +1,10 @@
+export * from "./common.js";
+import { ResultAsync } from "neverthrow";
+import type { Time } from "@darco2903/secondthought";
+import { type JWTVerifyError, type CdnFeedbackTokenData, type CdnAssetTokenDataDecoded, type JWTSignError } from "./common.js";
+export declare function JWTVerify(token: string, pubKey: string): ResultAsync<CdnAssetTokenDataDecoded, 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 declare function JWTSign(payload: CdnFeedbackTokenData, privKey: string, expiresIn: number | Time): ResultAsync<string, JWTSignError>;

package/dist/server.js

@@ -0,0 +1,58 @@
+export * from "./common.js";
+import jwt from "jsonwebtoken";
+import { ResultAsync } from "neverthrow";
+import { cdnAssetTokenDataDecodedSchema, } from "./common.js";
+import { JWT_ALGORITHM } from "./consts.js";
+export function JWTVerify(token, pubKey) {
+    return ResultAsync.fromPromise(new Promise((resolve, reject) => {
+        jwt.verify(token, pubKey, { algorithms: [JWT_ALGORITHM] }, (e, decoded) => {
+            if (e) {
+                reject({
+                    name: e.name,
+                    message: e.message,
+                });
+            }
+            else if (decoded === undefined) {
+                reject({
+                    name: "InvalidToken",
+                    message: "Token is undefined",
+                });
+            }
+            else {
+                const res = cdnAssetTokenDataDecodedSchema.safeParse(decoded);
+                if (res.success) {
+                    resolve(res.data);
+                }
+                else {
+                    reject({
+                        name: "InvalidTokenData",
+                        message: "Invalid token data",
+                    });
+                }
+            }
+        });
+    }), (e) => e);
+}
+/**
+ * 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, privKey, expiresIn) {
+    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",
+                });
+            }
+            else {
+                resolve(token);
+            }
+        });
+    }), (e) => e);
+}

package/{src/socket/index.ts → dist/socket/index.d.ts}

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

package/dist/socket/index.js

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

package/dist/socket/interface/index.d.ts

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

package/dist/socket/interface/index.js

@@ -0,0 +1 @@
+export {};

package/{src/socket/interface/template.ts → dist/socket/interface/template.d.ts}

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

package/dist/socket/interface/template.js

@@ -0,0 +1 @@
+export {};

package/dist/socket/types.d.ts

@@ -0,0 +1,3 @@
+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/dist/socket/types.js

@@ -0,0 +1 @@
+export {};

package/dist/types/creds.d.ts

@@ -0,0 +1,8 @@
+import z from "zod";
+export declare const cdnHeaderSchema: z.ZodObject<{
+    authorization: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    authorization: string;
+}, {
+    authorization: string;
+}>;

package/{src/types/creds.ts → dist/types/creds.js}

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

package/dist/types/endpoint.d.ts

@@ -0,0 +1,25 @@
+import z from "zod";
+export declare const endpointPathSchema: z.ZodString;
+export declare const endpointPublicSchema: z.ZodObject<{
+    endpoint: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    endpoint: string;
+}, {
+    endpoint: string;
+}>;
+export type EndpointPublic = z.infer<typeof endpointPublicSchema>;
+export declare const endpointSchema: z.ZodObject<{
+    endpoint: z.ZodString;
+} & {
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    created_at: Date;
+    updated_at: Date;
+    endpoint: string;
+}, {
+    created_at: Date;
+    updated_at: Date;
+    endpoint: string;
+}>;
+export type Endpoint = z.infer<typeof endpointSchema>;

package/{src/types/endpoint.ts → dist/types/endpoint.js}

@@ -1,19 +1,12 @@
-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>;
+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 const endpointSchema = endpointPublicSchema.extend({
+    created_at: z.coerce.date(),
+    updated_at: z.coerce.date(),
+});

package/{src/types/index.ts → dist/types/index.d.ts}

@@ -1,6 +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";
+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/dist/types/index.js

@@ -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/dist/types/jwt.d.ts

@@ -0,0 +1,128 @@
+import z from "zod";
+export type JWTVerifyError = {
+    name: "TokenExpiredError" | "JsonWebTokenError" | "NotBeforeError" | "InvalidToken" | "InvalidTokenData";
+    message: string;
+};
+export type JWTSignError = {
+    name: "InvalidTokenData" | "JsonWebTokenError";
+    message: string;
+};
+export declare const jwtSchema: z.ZodString;
+export declare const cdnAssetHeaderSchema: z.ZodObject<{
+    "x-cdn-asset": z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    "x-cdn-asset"?: string | undefined;
+}, {
+    "x-cdn-asset"?: string | undefined;
+}>;
+export declare const cdnAssetTokenDataSchema: z.ZodObject<{
+    service: z.ZodLiteral<"auth">;
+    type: z.ZodLiteral<"avatar">;
+    endpoint: z.ZodString;
+    user_public_id: z.ZodString;
+    file_size_max: z.ZodOptional<z.ZodNumber>;
+    allowed_file_types: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    callback_url: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "avatar";
+    endpoint: string;
+    service: "auth";
+    user_public_id: string;
+    file_size_max?: number | undefined;
+    allowed_file_types?: string[] | undefined;
+    callback_url?: string | undefined;
+}, {
+    type: "avatar";
+    endpoint: string;
+    service: "auth";
+    user_public_id: string;
+    file_size_max?: number | undefined;
+    allowed_file_types?: string[] | undefined;
+    callback_url?: string | undefined;
+}>;
+export declare const cdnAssetTokenDataDecodedSchema: z.ZodIntersection<z.ZodObject<{
+    service: z.ZodLiteral<"auth">;
+    type: z.ZodLiteral<"avatar">;
+    endpoint: z.ZodString;
+    user_public_id: z.ZodString;
+    file_size_max: z.ZodOptional<z.ZodNumber>;
+    allowed_file_types: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    callback_url: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "avatar";
+    endpoint: string;
+    service: "auth";
+    user_public_id: string;
+    file_size_max?: number | undefined;
+    allowed_file_types?: string[] | undefined;
+    callback_url?: string | undefined;
+}, {
+    type: "avatar";
+    endpoint: string;
+    service: "auth";
+    user_public_id: string;
+    file_size_max?: number | undefined;
+    allowed_file_types?: string[] | undefined;
+    callback_url?: string | undefined;
+}>, z.ZodObject<{
+    iat: z.ZodNumber;
+    exp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    iat: number;
+    exp: number;
+}, {
+    iat: number;
+    exp: number;
+}>>;
+export type CdnAssetTokenData = z.infer<typeof cdnAssetTokenDataSchema>;
+export type CdnAssetTokenDataDecoded = z.infer<typeof cdnAssetTokenDataDecodedSchema>;
+export declare const cdnFeedbackHeaderSchema: z.ZodObject<{
+    authorization: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    authorization?: string | undefined;
+}, {
+    authorization?: string | undefined;
+}>;
+export declare const cdnFeedbackTokenDataSchema: z.ZodObject<{
+    service: z.ZodLiteral<"auth">;
+    type: z.ZodEnum<["avatar"]>;
+    endpoint: z.ZodString;
+    user_public_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "avatar";
+    endpoint: string;
+    service: "auth";
+    user_public_id: string;
+}, {
+    type: "avatar";
+    endpoint: string;
+    service: "auth";
+    user_public_id: string;
+}>;
+export declare const cdnFeedbackTokenDecodedSchema: z.ZodIntersection<z.ZodObject<{
+    service: z.ZodLiteral<"auth">;
+    type: z.ZodEnum<["avatar"]>;
+    endpoint: z.ZodString;
+    user_public_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "avatar";
+    endpoint: string;
+    service: "auth";
+    user_public_id: string;
+}, {
+    type: "avatar";
+    endpoint: string;
+    service: "auth";
+    user_public_id: string;
+}>, z.ZodObject<{
+    iat: z.ZodNumber;
+    exp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    iat: number;
+    exp: number;
+}, {
+    iat: number;
+    exp: number;
+}>>;
+export type CdnFeedbackTokenData = z.infer<typeof cdnFeedbackTokenDataSchema>;
+export type CdnFeedbackTokenDataDecoded = z.infer<typeof cdnFeedbackTokenDecodedSchema>;

package/dist/types/jwt.js

@@ -0,0 +1,33 @@
+import z from "zod";
+import { authAssetTypeSchema, authServiceSchema, userPublicIdSchema, } from "@darco2903/auth-api/client";
+import { endpointPathSchema } from "./endpoint.js";
+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 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);

package/dist/types/record.d.ts

@@ -0,0 +1,97 @@
+import z from "zod";
+export declare const storagePublicIdSchema: z.ZodString;
+export declare const recordPublicSchema: z.ZodObject<{
+    storage_id: z.ZodString;
+    filename: z.ZodString;
+    size: z.ZodNumber;
+    mime_type: z.ZodString;
+    endpoints: z.ZodArray<z.ZodObject<{
+        endpoint: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        endpoint: string;
+    }, {
+        endpoint: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    filename: string;
+    size: number;
+    storage_id: string;
+    mime_type: string;
+    endpoints: {
+        endpoint: string;
+    }[];
+}, {
+    filename: string;
+    size: number;
+    storage_id: string;
+    mime_type: string;
+    endpoints: {
+        endpoint: string;
+    }[];
+}>;
+export type RecordPublic = z.infer<typeof recordPublicSchema>;
+export declare const recordTypeSchema: z.ZodEnum<["service", "system", "user"]>;
+export type RecordType = z.infer<typeof recordTypeSchema>;
+export declare const recordSchema: z.ZodObject<{
+    storage_id: z.ZodString;
+    filename: z.ZodString;
+    size: z.ZodNumber;
+    mime_type: z.ZodString;
+} & {
+    endpoints: z.ZodArray<z.ZodObject<{
+        endpoint: z.ZodString;
+    } & {
+        created_at: z.ZodDate;
+        updated_at: z.ZodDate;
+    }, "strip", z.ZodTypeAny, {
+        created_at: Date;
+        updated_at: Date;
+        endpoint: string;
+    }, {
+        created_at: Date;
+        updated_at: Date;
+        endpoint: string;
+    }>, "many">;
+    role: z.ZodNumber;
+    user_id: z.ZodNullable<z.ZodString>;
+    type: z.ZodEnum<["service", "system", "user"]>;
+    visible: z.ZodBoolean;
+    active: z.ZodBoolean;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    type: "user" | "service" | "system";
+    filename: string;
+    active: boolean;
+    visible: boolean;
+    role: number;
+    size: number;
+    created_at: Date;
+    updated_at: Date;
+    storage_id: string;
+    mime_type: string;
+    endpoints: {
+        created_at: Date;
+        updated_at: Date;
+        endpoint: string;
+    }[];
+    user_id: string | null;
+}, {
+    type: "user" | "service" | "system";
+    filename: string;
+    active: boolean;
+    visible: boolean;
+    role: number;
+    size: number;
+    created_at: Date;
+    updated_at: Date;
+    storage_id: string;
+    mime_type: string;
+    endpoints: {
+        created_at: Date;
+        updated_at: Date;
+        endpoint: string;
+    }[];
+    user_id: string | null;
+}>;
+export type Record = z.infer<typeof recordSchema>;