@darco2903/auth-api 2.0.4-beta.0

package/dist/contract/user.js

@@ -0,0 +1,107 @@
+import { initContract, ZodErrorSchema } from "@ts-rest/core";
+import z from "zod";
+import { apiError, apiSuccess } from "../types.js";
+import { authHeaderSchema, emailSchema, passwordSchema, usernameSchema, userPublicIdSchema, userPublicSchema, userSchema, } from "../types/index.js";
+const c = initContract();
+export default c.router({
+    fromId: {
+        method: "GET",
+        path: "/user/id/:userId",
+        description: "Get user by ID",
+        pathParams: z.object({
+            userId: userPublicIdSchema,
+        }),
+        responses: {
+            200: apiSuccess(userPublicSchema),
+            400: ZodErrorSchema,
+            404: apiError(z.literal("NOT_FOUND"), z.literal("User not found")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    fromIds: {
+        method: "GET",
+        path: "/user/ids",
+        description: "Get users by IDs",
+        query: z.object({
+            userIds: z.array(userPublicIdSchema),
+        }),
+        responses: {
+            200: apiSuccess(z.array(userPublicSchema)),
+            400: ZodErrorSchema,
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    me: {
+        method: "GET",
+        path: "/user/me",
+        description: "Get current user",
+        headers: authHeaderSchema,
+        responses: {
+            200: apiSuccess(userSchema),
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            404: apiError(z.literal("NOT_FOUND"), z.literal("User not found")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    updateEmail: {
+        method: "PATCH",
+        path: "/user/email",
+        description: "Update email for current user",
+        headers: authHeaderSchema,
+        body: z.object({
+            email: emailSchema,
+        }),
+        responses: {
+            200: apiSuccess(c.noBody()),
+            400: ZodErrorSchema,
+            401: apiError(z.literal("UNAUTHORIZED"), z.string()),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    updatePassword: {
+        method: "PATCH",
+        path: "/user/password",
+        description: "Update password for current user",
+        headers: authHeaderSchema,
+        body: z.object({
+            password: passwordSchema,
+            disconnectAll: z.boolean().default(true),
+        }),
+        responses: {
+            200: apiSuccess(c.noBody()),
+            400: ZodErrorSchema,
+            401: apiError(z.literal("UNAUTHORIZED"), z.string()),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    updateUsername: {
+        method: "PATCH",
+        path: "/user/username",
+        description: "Update username for current user",
+        headers: authHeaderSchema,
+        body: z.object({
+            username: usernameSchema,
+        }),
+        responses: {
+            200: apiSuccess(c.noBody()),
+            400: ZodErrorSchema,
+            401: apiError(z.literal("UNAUTHORIZED"), z.string()),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    updateBorder: {
+        method: "POST",
+        path: "/user/picture/profile/border",
+        description: "Set border for user profile picture",
+        headers: authHeaderSchema,
+        body: z.object({
+            roundBorder: z.boolean(),
+        }),
+        responses: {
+            200: apiSuccess(c.noBody()),
+            400: ZodErrorSchema,
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+});

package/dist/index.d.ts

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

@@ -0,0 +1,11 @@
+export declare enum UserRole {
+    Banned = -1,
+    Guest = 0,
+    Newbie = 10,
+    User = 50,
+    Moderator = 100,
+    Admin = 150,
+    SuperAdmin = 200,
+    Developer = 250,
+    Owner = 255
+}

package/dist/roles.js

@@ -0,0 +1,12 @@
+export var UserRole;
+(function (UserRole) {
+    UserRole[UserRole["Banned"] = -1] = "Banned";
+    UserRole[UserRole["Guest"] = 0] = "Guest";
+    UserRole[UserRole["Newbie"] = 10] = "Newbie";
+    UserRole[UserRole["User"] = 50] = "User";
+    UserRole[UserRole["Moderator"] = 100] = "Moderator";
+    UserRole[UserRole["Admin"] = 150] = "Admin";
+    UserRole[UserRole["SuperAdmin"] = 200] = "SuperAdmin";
+    UserRole[UserRole["Developer"] = 250] = "Developer";
+    UserRole[UserRole["Owner"] = 255] = "Owner";
+})(UserRole || (UserRole = {}));

package/dist/server.d.ts

@@ -0,0 +1,11 @@
+export * from "./common.js";
+import { ResultAsync } from "neverthrow";
+import type { Time } from "@darco2903/secondthought";
+import type { CdnAssetTokenData } from "@darco2903/cdn-api/server";
+import { type JWTVerifyError, type AccessTokenData, type AccessTokenDataDecoded, type JWTSignError } from "./types/index.js";
+export declare function JWTVerify(token: string, pubKey: string): ResultAsync<AccessTokenDataDecoded, 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: AccessTokenData | CdnAssetTokenData, 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 { accessTokenDataDecodedSchema, } from "./types/index.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 = accessTokenDataDecodedSchema.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/dist/types/assets.d.ts

@@ -0,0 +1,5 @@
+import z from "zod";
+export declare const authServiceSchema: z.ZodLiteral<"auth">;
+export type AuthService = z.infer<typeof authServiceSchema>;
+export declare const authAssetTypeSchema: z.ZodEnum<["avatar"]>;
+export type AuthAssetTypes = z.infer<typeof authAssetTypeSchema>;

package/dist/types/assets.js

@@ -0,0 +1,3 @@
+import z from "zod";
+export const authServiceSchema = z.literal("auth");
+export const authAssetTypeSchema = z.enum(["avatar"]);

package/dist/types/auth.d.ts

@@ -0,0 +1,26 @@
+import z from "zod";
+export declare const accessSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    expiresIn: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    accessToken: string;
+    expiresIn: number;
+}, {
+    accessToken: string;
+    expiresIn: number;
+}>;
+export declare const accessRefreshSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    expiresIn: z.ZodNumber;
+} & {
+    refreshToken: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    accessToken: string;
+    expiresIn: number;
+    refreshToken: string;
+}, {
+    accessToken: string;
+    expiresIn: number;
+    refreshToken: string;
+}>;
+export declare const totpCodeSchema: z.ZodString;

package/dist/types/auth.js

@@ -0,0 +1,9 @@
+import z from "zod";
+export const accessSchema = z.object({
+    accessToken: z.string(),
+    expiresIn: z.number().int().min(0),
+});
+export const accessRefreshSchema = accessSchema.extend({
+    refreshToken: z.string(),
+});
+export const totpCodeSchema = z.string().min(6).max(6);

package/dist/types/creds.d.ts

@@ -0,0 +1,8 @@
+import z from "zod";
+export declare const tokenSchema: z.ZodString;
+export declare const emailSchema: z.ZodString;
+export declare const emailCredentialSchema: z.ZodString;
+export declare const passwordSchema: z.ZodString;
+export declare const passwordCredentialSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const usernameSchema: z.ZodString;
+export declare const turnstileSchema: z.ZodString;

package/dist/types/creds.js

@@ -0,0 +1,44 @@
+import z from "zod";
+import { PASSWORD_MAX_LENGTH, PASSWORD_MIN_LENGTH, NAME_MAX_LENGTH, NAME_MIN_LENGTH, EMAIL_MAX_LENGTH, } from "../consts.js";
+export const tokenSchema = z.string().nonempty("Token is required");
+const emailSchemaBase = z.string().max(EMAIL_MAX_LENGTH, "Email is too long");
+export const emailSchema = emailSchemaBase.email();
+export const emailCredentialSchema = emailSchemaBase.email({
+    message: "Invalid Credentials",
+});
+// const REGEX_LOWER = /[a-z]/; // contains at least one lowercase letter
+// const REGEX_UPPER = /[A-Z]/; // contains at least one uppercase letter
+// const REGEX_NUMBER = /[0-9]/; // contains at least one number
+// const REGEX_SPECIAL = /[" !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"]/; // contains at least one special character
+export const passwordSchema = z
+    .string()
+    // .regex(REGEX_LOWER, "Password must contain at least one lowercase letter")
+    // .regex(REGEX_UPPER, "Password must contain at least one uppercase letter")
+    // .regex(REGEX_NUMBER, "Password must contain at least one number")
+    // .regex(
+    //     REGEX_SPECIAL,
+    //     "Password must contain at least one special character"
+    // )
+    .min(PASSWORD_MIN_LENGTH, "Password is too short")
+    .max(PASSWORD_MAX_LENGTH, "Password is too long");
+export const passwordCredentialSchema = z.string().superRefine((val, ctx) => {
+    // const hasLower = REGEX_LOWER.test(val);
+    // const hasUpper = REGEX_UPPER.test(val);
+    // const hasNumber = REGEX_NUMBER.test(val);
+    // const hasSpecial = REGEX_SPECIAL.test(val);
+    const validLength = val.length >= PASSWORD_MIN_LENGTH && val.length <= PASSWORD_MAX_LENGTH;
+    // if (!(hasLower && hasUpper && hasNumber && hasSpecial && validLength)) {
+    if (!validLength) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Invalid Credentials",
+        });
+    }
+});
+export const usernameSchema = z
+    .string()
+    .min(NAME_MIN_LENGTH, "Username is too short")
+    .max(NAME_MAX_LENGTH, "Username is too long");
+export const turnstileSchema = z
+    .string()
+    .nonempty({ message: "Turnstile token is required" });

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./assets.js";
+export * from "./auth.js";
+export * from "./creds.js";
+export * from "./jwt.js";
+export * from "./user.js";

package/dist/types/index.js

@@ -0,0 +1,5 @@
+export * from "./assets.js";
+export * from "./auth.js";
+export * from "./creds.js";
+export * from "./jwt.js";
+export * from "./user.js";

package/dist/types/jwt.d.ts

@@ -0,0 +1,73 @@
+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 authHeaderSchema: z.ZodObject<{
+    authorization: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    authorization?: string | undefined;
+}, {
+    authorization?: string | undefined;
+}>;
+export declare const accessTokenDataSchema: z.ZodObject<{
+    public_id: z.ZodString;
+    role: z.ZodNumber;
+    password_reset: z.ZodOptional<z.ZodString>;
+    totp_required: z.ZodBoolean;
+    totp_verified: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    role: number;
+    public_id: string;
+    totp_required: boolean;
+    totp_verified: boolean;
+    password_reset?: string | undefined;
+}, {
+    role: number;
+    public_id: string;
+    totp_required: boolean;
+    totp_verified: boolean;
+    password_reset?: string | undefined;
+}>;
+export type AccessTokenData = z.infer<typeof accessTokenDataSchema>;
+export declare const accessTokenDataDecodedSchema: z.ZodIntersection<z.ZodObject<{
+    iat: z.ZodNumber;
+    exp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    exp: number;
+    iat: number;
+}, {
+    exp: number;
+    iat: number;
+}>, z.ZodObject<{
+    public_id: z.ZodString;
+    role: z.ZodNumber;
+    password_reset: z.ZodOptional<z.ZodString>;
+    totp_required: z.ZodBoolean;
+    totp_verified: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    role: number;
+    public_id: string;
+    totp_required: boolean;
+    totp_verified: boolean;
+    password_reset?: string | undefined;
+}, {
+    role: number;
+    public_id: string;
+    totp_required: boolean;
+    totp_verified: boolean;
+    password_reset?: string | undefined;
+}>>;
+export type AccessTokenDataDecoded = z.infer<typeof accessTokenDataDecodedSchema>;
+export declare const cdnFeedbackHeaderSchema: z.ZodObject<{
+    authorization: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    authorization: string;
+}, {
+    authorization: string;
+}>;

package/dist/types/jwt.js

@@ -0,0 +1,23 @@
+import z from "zod";
+import { userPublicIdSchema } from "./user.js";
+const JWTData = z.object({
+    iat: z.number(),
+    exp: z.number(),
+});
+export const jwtSchema = z.string().startsWith("Bearer ");
+///////////////////////////////////
+export const authHeaderSchema = z.object({
+    authorization: jwtSchema.optional(),
+});
+export const accessTokenDataSchema = z.object({
+    public_id: userPublicIdSchema,
+    role: z.number().int().min(-1).max(255),
+    password_reset: z.string().optional(),
+    totp_required: z.boolean(),
+    totp_verified: z.boolean(),
+});
+export const accessTokenDataDecodedSchema = z.intersection(JWTData, accessTokenDataSchema);
+///////////////////////////////////
+export const cdnFeedbackHeaderSchema = z.object({
+    authorization: jwtSchema,
+});

package/dist/types/user.d.ts

@@ -0,0 +1,90 @@
+import z from "zod";
+export declare const userPublicIdSchema: z.ZodString;
+declare const userAssetsSchema: z.ZodObject<{
+    avatar: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    avatar: string | null;
+}, {
+    avatar: string | null;
+}>;
+export type UserAssets = z.infer<typeof userAssetsSchema>;
+export declare const userPublicSchema: z.ZodObject<{
+    public_id: z.ZodString;
+    name: z.ZodString;
+    assets: z.ZodObject<{
+        avatar: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        avatar: string | null;
+    }, {
+        avatar: string | null;
+    }>;
+    round_border: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    public_id: string;
+    assets: {
+        avatar: string | null;
+    };
+    round_border: boolean;
+}, {
+    name: string;
+    public_id: string;
+    assets: {
+        avatar: string | null;
+    };
+    round_border: boolean;
+}>;
+export type UserPublic = z.infer<typeof userPublicSchema>;
+export declare const userSchema: z.ZodObject<{
+    public_id: z.ZodString;
+    name: z.ZodString;
+    assets: z.ZodObject<{
+        avatar: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        avatar: string | null;
+    }, {
+        avatar: string | null;
+    }>;
+    round_border: z.ZodBoolean;
+} & {
+    email: z.ZodString;
+    role: z.ZodNumber;
+    verified: z.ZodBoolean;
+    last_login: z.ZodNullable<z.ZodDate>;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+    email_verif: z.ZodNullable<z.ZodDate>;
+    password_reset: z.ZodNullable<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    role: number;
+    email: string;
+    public_id: string;
+    assets: {
+        avatar: string | null;
+    };
+    round_border: boolean;
+    verified: boolean;
+    last_login: Date | null;
+    created_at: Date;
+    updated_at: Date;
+    email_verif: Date | null;
+    password_reset: Date | null;
+}, {
+    name: string;
+    role: number;
+    email: string;
+    public_id: string;
+    assets: {
+        avatar: string | null;
+    };
+    round_border: boolean;
+    verified: boolean;
+    last_login: Date | null;
+    created_at: Date;
+    updated_at: Date;
+    email_verif: Date | null;
+    password_reset: Date | null;
+}>;
+export type User = z.infer<typeof userSchema>;
+export {};

package/dist/types/user.js

@@ -0,0 +1,26 @@
+import z from "zod";
+import { USER_PUBLIC_ID_LENGTH } from "../consts.js";
+export const userPublicIdSchema = z
+    .string()
+    .length(USER_PUBLIC_ID_LENGTH)
+    .regex(/^[a-zA-Z0-9]+$/);
+const asset = z.string().url().nullable();
+const userAssetsSchema = z.object({
+    avatar: asset,
+});
+export const userPublicSchema = z.object({
+    public_id: z.string(),
+    name: z.string(),
+    assets: userAssetsSchema,
+    round_border: z.boolean(),
+});
+export const userSchema = userPublicSchema.extend({
+    email: z.string().email(),
+    role: z.number().int().min(-1, "Invalid level").max(255, "Invalid level"),
+    verified: z.boolean(),
+    last_login: z.date().nullable(),
+    created_at: z.date(),
+    updated_at: z.date(),
+    email_verif: z.date().nullable(),
+    password_reset: z.date().nullable(),
+});

package/dist/types.d.ts

@@ -0,0 +1,32 @@
+import { z, type ZodType } from "zod";
+import type { ContractNoBodyType } from "@ts-rest/core";
+export declare const apiSuccess: <T extends ZodType | ContractNoBodyType>(schema: T) => T;
+export declare const apiError: <T, U>(code: ZodType<T>, error: ZodType<U>) => z.ZodObject<{
+    code: z.ZodType<T, z.ZodTypeDef, T>;
+    error: z.ZodType<U, z.ZodTypeDef, U>;
+    name: z.ZodLiteral<"APIError">;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    code: z.ZodType<T, z.ZodTypeDef, T>;
+    error: z.ZodType<U, z.ZodTypeDef, U>;
+    name: z.ZodLiteral<"APIError">;
+}>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<{
+    code: z.ZodType<T, z.ZodTypeDef, T>;
+    error: z.ZodType<U, z.ZodTypeDef, U>;
+    name: z.ZodLiteral<"APIError">;
+}> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never>;
+export declare const apiErrorData: <T, U, V>(code: ZodType<T>, error: ZodType<U>, data: ZodType<V>) => z.ZodObject<{
+    code: z.ZodType<T, z.ZodTypeDef, T>;
+    error: z.ZodType<U, z.ZodTypeDef, U>;
+    name: z.ZodLiteral<"APIError">;
+    data: z.ZodType<V, z.ZodTypeDef, V>;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    code: z.ZodType<T, z.ZodTypeDef, T>;
+    error: z.ZodType<U, z.ZodTypeDef, U>;
+    name: z.ZodLiteral<"APIError">;
+    data: z.ZodType<V, z.ZodTypeDef, V>;
+}>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<{
+    code: z.ZodType<T, z.ZodTypeDef, T>;
+    error: z.ZodType<U, z.ZodTypeDef, U>;
+    name: z.ZodLiteral<"APIError">;
+    data: z.ZodType<V, z.ZodTypeDef, V>;
+}> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never>;

package/dist/types.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export const apiSuccess = (schema) => schema;
+export const apiError = (code, error) => z.object({
+    code,
+    error,
+    name: z.literal("APIError"),
+});
+export const apiErrorData = (code, error, data) => z.object({
+    code,
+    error,
+    name: z.literal("APIError"),
+    data,
+});

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@darco2903/auth-api",
+  "version": "2.0.4-beta.0",
+  "description": "",
+  "main": "./dist/index.js",
+  "type": "module",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "repository": {
+    "url": "https://github.com/Darco2903/web-common.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./client": "./dist/client.js",
+    "./server": "./dist/server.js"
+  },
+  "dependencies": {
+    "@darco2903/cdn-api": "^1.0.6",
+    "@ts-rest/core": "^3.52.1",
+    "@ts-rest/open-api": "^3.52.1",
+    "jsonwebtoken": "^9.0.3",
+    "neverthrow": "^8.2.0",
+    "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 openapi.json darco2903-auth-api-*.tgz",
+    "generate:openapi": "tsx tools/generate-openapi.ts"
+  }
+}

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: "Auth API",
+        version,
+    },
+    servers: [
+        {
+            url: "https://auth.darco2903.fr",
+        },
+        {
+            url: "https://dev-auth.darco2903.fr",
+        },
+    ],
+});
+
+fs.writeFileSync("openapi.json", JSON.stringify(openApiDocument, null, 2));