@darco2903/auth-api 2.0.4-beta.0

package/dist/client.js

@@ -0,0 +1,32 @@
+import { Second } from "@darco2903/secondthought";
+export * from "./common.js";
+import { initClient } from "@ts-rest/core";
+import contract from "./contract/index.js";
+import { UserRole } from "./roles.js";
+export function createClient(origin) {
+    return initClient(contract, {
+        baseUrl: origin,
+        credentials: "include",
+    });
+}
+export function getRoleName(level) {
+    return UserRole[level] || "Unknown";
+}
+export function getRoleLevel(name) {
+    return UserRole[name] || -1;
+}
+export function accessTokenExpiresAt() {
+    if (document) {
+        const expiresAtCookie = document.cookie
+            .split("; ")
+            .find((row) => row.startsWith("expiresAt="))
+            ?.split("=")[1];
+        if (expiresAtCookie) {
+            const expiresAt = Number(expiresAtCookie);
+            if (!isNaN(expiresAt)) {
+                return new Second(expiresAt).toDate();
+            }
+        }
+    }
+    return null;
+}

package/dist/common.d.ts

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

package/dist/common.js

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

package/dist/consts.d.ts

@@ -0,0 +1,10 @@
+import type { Algorithm } from "jsonwebtoken";
+export declare const API_VERSION = "v2";
+export declare const API_PATH_PREFIX = "/api/v2";
+export declare const JWT_ALGORITHM: Algorithm;
+export declare const NAME_MIN_LENGTH = 3;
+export declare const NAME_MAX_LENGTH = 32;
+export declare const EMAIL_MAX_LENGTH = 255;
+export declare const PASSWORD_MIN_LENGTH = 8;
+export declare const PASSWORD_MAX_LENGTH = 72;
+export declare const USER_PUBLIC_ID_LENGTH = 8;

package/dist/consts.js

@@ -0,0 +1,9 @@
+export const API_VERSION = "v2";
+export const API_PATH_PREFIX = `/api/${API_VERSION}`;
+export const JWT_ALGORITHM = "ES256";
+export const NAME_MIN_LENGTH = 3;
+export const NAME_MAX_LENGTH = 32;
+export const EMAIL_MAX_LENGTH = 255;
+export const PASSWORD_MIN_LENGTH = 8;
+export const PASSWORD_MAX_LENGTH = 72; // bcrypt truncates passwords to 72 characters
+export const USER_PUBLIC_ID_LENGTH = 8;

package/dist/contract/assets.d.ts

@@ -0,0 +1,356 @@
+import z from "zod";
+declare const _default: {
+    token: {
+        body: z.ZodObject<{
+            type: z.ZodEnum<["avatar"]>;
+        }, "strip", z.ZodTypeAny, {
+            type: "avatar";
+        }, {
+            type: "avatar";
+        }>;
+        method: "POST";
+        path: "/assets/token";
+        headers: z.ZodObject<{
+            authorization: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            authorization?: string | undefined;
+        }, {
+            authorization?: string | undefined;
+        }>;
+        responses: {
+            200: z.ZodObject<{
+                cdnToken: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                cdnToken: string;
+            }, {
+                cdnToken: string;
+            }>;
+            400: z.ZodObject<{
+                name: z.ZodLiteral<"ZodError">;
+                issues: z.ZodArray<z.ZodObject<{
+                    path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+                    message: z.ZodOptional<z.ZodString>;
+                    code: z.ZodNativeEnum<{
+                        invalid_type: "invalid_type";
+                        invalid_literal: "invalid_literal";
+                        custom: "custom";
+                        invalid_union: "invalid_union";
+                        invalid_union_discriminator: "invalid_union_discriminator";
+                        invalid_enum_value: "invalid_enum_value";
+                        unrecognized_keys: "unrecognized_keys";
+                        invalid_arguments: "invalid_arguments";
+                        invalid_return_type: "invalid_return_type";
+                        invalid_date: "invalid_date";
+                        invalid_string: "invalid_string";
+                        too_small: "too_small";
+                        too_big: "too_big";
+                        invalid_intersection_types: "invalid_intersection_types";
+                        not_multiple_of: "not_multiple_of";
+                        not_finite: "not_finite";
+                    }>;
+                }, "strip", z.ZodAny, z.objectOutputType<{
+                    path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+                    message: z.ZodOptional<z.ZodString>;
+                    code: z.ZodNativeEnum<{
+                        invalid_type: "invalid_type";
+                        invalid_literal: "invalid_literal";
+                        custom: "custom";
+                        invalid_union: "invalid_union";
+                        invalid_union_discriminator: "invalid_union_discriminator";
+                        invalid_enum_value: "invalid_enum_value";
+                        unrecognized_keys: "unrecognized_keys";
+                        invalid_arguments: "invalid_arguments";
+                        invalid_return_type: "invalid_return_type";
+                        invalid_date: "invalid_date";
+                        invalid_string: "invalid_string";
+                        too_small: "too_small";
+                        too_big: "too_big";
+                        invalid_intersection_types: "invalid_intersection_types";
+                        not_multiple_of: "not_multiple_of";
+                        not_finite: "not_finite";
+                    }>;
+                }, z.ZodAny, "strip">, z.objectInputType<{
+                    path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+                    message: z.ZodOptional<z.ZodString>;
+                    code: z.ZodNativeEnum<{
+                        invalid_type: "invalid_type";
+                        invalid_literal: "invalid_literal";
+                        custom: "custom";
+                        invalid_union: "invalid_union";
+                        invalid_union_discriminator: "invalid_union_discriminator";
+                        invalid_enum_value: "invalid_enum_value";
+                        unrecognized_keys: "unrecognized_keys";
+                        invalid_arguments: "invalid_arguments";
+                        invalid_return_type: "invalid_return_type";
+                        invalid_date: "invalid_date";
+                        invalid_string: "invalid_string";
+                        too_small: "too_small";
+                        too_big: "too_big";
+                        invalid_intersection_types: "invalid_intersection_types";
+                        not_multiple_of: "not_multiple_of";
+                        not_finite: "not_finite";
+                    }>;
+                }, z.ZodAny, "strip">>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                name: "ZodError";
+                issues: z.objectOutputType<{
+                    path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+                    message: z.ZodOptional<z.ZodString>;
+                    code: z.ZodNativeEnum<{
+                        invalid_type: "invalid_type";
+                        invalid_literal: "invalid_literal";
+                        custom: "custom";
+                        invalid_union: "invalid_union";
+                        invalid_union_discriminator: "invalid_union_discriminator";
+                        invalid_enum_value: "invalid_enum_value";
+                        unrecognized_keys: "unrecognized_keys";
+                        invalid_arguments: "invalid_arguments";
+                        invalid_return_type: "invalid_return_type";
+                        invalid_date: "invalid_date";
+                        invalid_string: "invalid_string";
+                        too_small: "too_small";
+                        too_big: "too_big";
+                        invalid_intersection_types: "invalid_intersection_types";
+                        not_multiple_of: "not_multiple_of";
+                        not_finite: "not_finite";
+                    }>;
+                }, z.ZodAny, "strip">[];
+            }, {
+                name: "ZodError";
+                issues: z.objectInputType<{
+                    path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+                    message: z.ZodOptional<z.ZodString>;
+                    code: z.ZodNativeEnum<{
+                        invalid_type: "invalid_type";
+                        invalid_literal: "invalid_literal";
+                        custom: "custom";
+                        invalid_union: "invalid_union";
+                        invalid_union_discriminator: "invalid_union_discriminator";
+                        invalid_enum_value: "invalid_enum_value";
+                        unrecognized_keys: "unrecognized_keys";
+                        invalid_arguments: "invalid_arguments";
+                        invalid_return_type: "invalid_return_type";
+                        invalid_date: "invalid_date";
+                        invalid_string: "invalid_string";
+                        too_small: "too_small";
+                        too_big: "too_big";
+                        invalid_intersection_types: "invalid_intersection_types";
+                        not_multiple_of: "not_multiple_of";
+                        not_finite: "not_finite";
+                    }>;
+                }, z.ZodAny, "strip">[];
+            }>;
+            401: z.ZodObject<{
+                code: z.ZodType<"UNAUTHORIZED", z.ZodTypeDef, "UNAUTHORIZED">;
+                error: z.ZodType<"Unauthorized", z.ZodTypeDef, "Unauthorized">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "UNAUTHORIZED";
+                name: "APIError";
+                error: "Unauthorized";
+            }, {
+                code: "UNAUTHORIZED";
+                name: "APIError";
+                error: "Unauthorized";
+            }>;
+        };
+    };
+    update: {
+        body: typeof import("@ts-rest/core").ContractNoBody;
+        method: "POST";
+        path: "/assets";
+        headers: z.ZodObject<{
+            authorization: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            authorization: string;
+        }, {
+            authorization: string;
+        }>;
+        responses: {
+            200: typeof import("@ts-rest/core").ContractNoBody;
+            400: z.ZodObject<{
+                name: z.ZodLiteral<"ZodError">;
+                issues: z.ZodArray<z.ZodObject<{
+                    path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+                    message: z.ZodOptional<z.ZodString>;
+                    code: z.ZodNativeEnum<{
+                        invalid_type: "invalid_type";
+                        invalid_literal: "invalid_literal";
+                        custom: "custom";
+                        invalid_union: "invalid_union";
+                        invalid_union_discriminator: "invalid_union_discriminator";
+                        invalid_enum_value: "invalid_enum_value";
+                        unrecognized_keys: "unrecognized_keys";
+                        invalid_arguments: "invalid_arguments";
+                        invalid_return_type: "invalid_return_type";
+                        invalid_date: "invalid_date";
+                        invalid_string: "invalid_string";
+                        too_small: "too_small";
+                        too_big: "too_big";
+                        invalid_intersection_types: "invalid_intersection_types";
+                        not_multiple_of: "not_multiple_of";
+                        not_finite: "not_finite";
+                    }>;
+                }, "strip", z.ZodAny, z.objectOutputType<{
+                    path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+                    message: z.ZodOptional<z.ZodString>;
+                    code: z.ZodNativeEnum<{
+                        invalid_type: "invalid_type";
+                        invalid_literal: "invalid_literal";
+                        custom: "custom";
+                        invalid_union: "invalid_union";
+                        invalid_union_discriminator: "invalid_union_discriminator";
+                        invalid_enum_value: "invalid_enum_value";
+                        unrecognized_keys: "unrecognized_keys";
+                        invalid_arguments: "invalid_arguments";
+                        invalid_return_type: "invalid_return_type";
+                        invalid_date: "invalid_date";
+                        invalid_string: "invalid_string";
+                        too_small: "too_small";
+                        too_big: "too_big";
+                        invalid_intersection_types: "invalid_intersection_types";
+                        not_multiple_of: "not_multiple_of";
+                        not_finite: "not_finite";
+                    }>;
+                }, z.ZodAny, "strip">, z.objectInputType<{
+                    path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+                    message: z.ZodOptional<z.ZodString>;
+                    code: z.ZodNativeEnum<{
+                        invalid_type: "invalid_type";
+                        invalid_literal: "invalid_literal";
+                        custom: "custom";
+                        invalid_union: "invalid_union";
+                        invalid_union_discriminator: "invalid_union_discriminator";
+                        invalid_enum_value: "invalid_enum_value";
+                        unrecognized_keys: "unrecognized_keys";
+                        invalid_arguments: "invalid_arguments";
+                        invalid_return_type: "invalid_return_type";
+                        invalid_date: "invalid_date";
+                        invalid_string: "invalid_string";
+                        too_small: "too_small";
+                        too_big: "too_big";
+                        invalid_intersection_types: "invalid_intersection_types";
+                        not_multiple_of: "not_multiple_of";
+                        not_finite: "not_finite";
+                    }>;
+                }, z.ZodAny, "strip">>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                name: "ZodError";
+                issues: z.objectOutputType<{
+                    path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+                    message: z.ZodOptional<z.ZodString>;
+                    code: z.ZodNativeEnum<{
+                        invalid_type: "invalid_type";
+                        invalid_literal: "invalid_literal";
+                        custom: "custom";
+                        invalid_union: "invalid_union";
+                        invalid_union_discriminator: "invalid_union_discriminator";
+                        invalid_enum_value: "invalid_enum_value";
+                        unrecognized_keys: "unrecognized_keys";
+                        invalid_arguments: "invalid_arguments";
+                        invalid_return_type: "invalid_return_type";
+                        invalid_date: "invalid_date";
+                        invalid_string: "invalid_string";
+                        too_small: "too_small";
+                        too_big: "too_big";
+                        invalid_intersection_types: "invalid_intersection_types";
+                        not_multiple_of: "not_multiple_of";
+                        not_finite: "not_finite";
+                    }>;
+                }, z.ZodAny, "strip">[];
+            }, {
+                name: "ZodError";
+                issues: z.objectInputType<{
+                    path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+                    message: z.ZodOptional<z.ZodString>;
+                    code: z.ZodNativeEnum<{
+                        invalid_type: "invalid_type";
+                        invalid_literal: "invalid_literal";
+                        custom: "custom";
+                        invalid_union: "invalid_union";
+                        invalid_union_discriminator: "invalid_union_discriminator";
+                        invalid_enum_value: "invalid_enum_value";
+                        unrecognized_keys: "unrecognized_keys";
+                        invalid_arguments: "invalid_arguments";
+                        invalid_return_type: "invalid_return_type";
+                        invalid_date: "invalid_date";
+                        invalid_string: "invalid_string";
+                        too_small: "too_small";
+                        too_big: "too_big";
+                        invalid_intersection_types: "invalid_intersection_types";
+                        not_multiple_of: "not_multiple_of";
+                        not_finite: "not_finite";
+                    }>;
+                }, z.ZodAny, "strip">[];
+            }>;
+            401: z.ZodObject<{
+                code: z.ZodType<"UNAUTHORIZED", z.ZodTypeDef, "UNAUTHORIZED">;
+                error: z.ZodType<"Unauthorized", z.ZodTypeDef, "Unauthorized">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "UNAUTHORIZED";
+                name: "APIError";
+                error: "Unauthorized";
+            }, {
+                code: "UNAUTHORIZED";
+                name: "APIError";
+                error: "Unauthorized";
+            }>;
+            500: z.ZodObject<{
+                code: z.ZodType<"INTERNAL_SERVER_ERROR", z.ZodTypeDef, "INTERNAL_SERVER_ERROR">;
+                error: z.ZodType<string, z.ZodTypeDef, string>;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "INTERNAL_SERVER_ERROR";
+                name: "APIError";
+                error: string;
+            }, {
+                code: "INTERNAL_SERVER_ERROR";
+                name: "APIError";
+                error: string;
+            }>;
+        };
+    };
+    delete: {
+        method: "DELETE";
+        description: "Delete user avatar picture";
+        path: "/assets";
+        headers: z.ZodObject<{
+            authorization: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            authorization: string;
+        }, {
+            authorization: string;
+        }>;
+        responses: {
+            200: typeof import("@ts-rest/core").ContractNoBody;
+            401: z.ZodObject<{
+                code: z.ZodType<"UNAUTHORIZED", z.ZodTypeDef, "UNAUTHORIZED">;
+                error: z.ZodType<"Unauthorized", z.ZodTypeDef, "Unauthorized">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "UNAUTHORIZED";
+                name: "APIError";
+                error: "Unauthorized";
+            }, {
+                code: "UNAUTHORIZED";
+                name: "APIError";
+                error: "Unauthorized";
+            }>;
+            500: z.ZodObject<{
+                code: z.ZodType<"INTERNAL_SERVER_ERROR", z.ZodTypeDef, "INTERNAL_SERVER_ERROR">;
+                error: z.ZodType<string, z.ZodTypeDef, string>;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "INTERNAL_SERVER_ERROR";
+                name: "APIError";
+                error: string;
+            }, {
+                code: "INTERNAL_SERVER_ERROR";
+                name: "APIError";
+                error: string;
+            }>;
+        };
+    };
+};
+export default _default;

package/dist/contract/assets.js

@@ -0,0 +1,45 @@
+import { initContract, ZodErrorSchema } from "@ts-rest/core";
+import z from "zod";
+import { apiError, apiSuccess } from "../types.js";
+import { authHeaderSchema, cdnFeedbackHeaderSchema, authAssetTypeSchema, } from "../types/index.js";
+const c = initContract();
+export default c.router({
+    token: {
+        method: "POST",
+        path: "/assets/token",
+        headers: authHeaderSchema,
+        body: z.object({
+            type: authAssetTypeSchema,
+        }),
+        responses: {
+            200: apiSuccess(z.object({
+                cdnToken: z.string(),
+            })),
+            400: ZodErrorSchema,
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+        },
+    },
+    update: {
+        method: "POST",
+        path: "/assets",
+        headers: cdnFeedbackHeaderSchema,
+        body: c.noBody(),
+        responses: {
+            200: apiSuccess(c.noBody()),
+            400: ZodErrorSchema,
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    delete: {
+        method: "DELETE",
+        path: "/assets",
+        description: "Delete user avatar picture",
+        headers: cdnFeedbackHeaderSchema,
+        responses: {
+            200: apiSuccess(c.noBody()),
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+});