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

package/dist/contract/record.d.ts

@@ -0,0 +1,412 @@
+import z from "zod";
+declare const _default: {
+    get: {
+        method: "GET";
+        path: "/record/:storage_id";
+        headers: z.ZodObject<{
+            authorization: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            authorization?: string | undefined;
+        }, {
+            authorization?: string | undefined;
+        }>;
+        responses: {
+            200: z.ZodType<{
+                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;
+            }, z.ZodTypeDef, {
+                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;
+            }>;
+            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";
+            }>;
+            403: z.ZodObject<{
+                code: z.ZodType<"FORBIDDEN", z.ZodTypeDef, "FORBIDDEN">;
+                error: z.ZodType<"Forbidden", z.ZodTypeDef, "Forbidden">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "FORBIDDEN";
+                name: "APIError";
+                error: "Forbidden";
+            }, {
+                code: "FORBIDDEN";
+                name: "APIError";
+                error: "Forbidden";
+            }>;
+            404: z.ZodObject<{
+                code: z.ZodType<"NOT_FOUND", z.ZodTypeDef, "NOT_FOUND">;
+                error: z.ZodType<"Record not found", z.ZodTypeDef, "Record not found">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "NOT_FOUND";
+                name: "APIError";
+                error: "Record not found";
+            }, {
+                code: "NOT_FOUND";
+                name: "APIError";
+                error: "Record not found";
+            }>;
+            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;
+            }>;
+        };
+    };
+    update: {
+        body: z.ZodUnion<[z.ZodObject<{
+            filename: z.ZodString;
+            role: z.ZodOptional<z.ZodNumber>;
+            active: z.ZodOptional<z.ZodBoolean>;
+            visible: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            filename: string;
+            active?: boolean | undefined;
+            visible?: boolean | undefined;
+            role?: number | undefined;
+        }, {
+            filename: string;
+            active?: boolean | undefined;
+            visible?: boolean | undefined;
+            role?: number | undefined;
+        }>, z.ZodObject<{
+            filename: z.ZodOptional<z.ZodString>;
+            role: z.ZodNumber;
+            active: z.ZodOptional<z.ZodBoolean>;
+            visible: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            role: number;
+            filename?: string | undefined;
+            active?: boolean | undefined;
+            visible?: boolean | undefined;
+        }, {
+            role: number;
+            filename?: string | undefined;
+            active?: boolean | undefined;
+            visible?: boolean | undefined;
+        }>, z.ZodObject<{
+            filename: z.ZodOptional<z.ZodString>;
+            role: z.ZodOptional<z.ZodNumber>;
+            active: z.ZodBoolean;
+            visible: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            active: boolean;
+            filename?: string | undefined;
+            visible?: boolean | undefined;
+            role?: number | undefined;
+        }, {
+            active: boolean;
+            filename?: string | undefined;
+            visible?: boolean | undefined;
+            role?: number | undefined;
+        }>, z.ZodObject<{
+            filename: z.ZodOptional<z.ZodString>;
+            role: z.ZodOptional<z.ZodNumber>;
+            active: z.ZodOptional<z.ZodBoolean>;
+            visible: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            visible: boolean;
+            filename?: string | undefined;
+            active?: boolean | undefined;
+            role?: number | undefined;
+        }, {
+            visible: boolean;
+            filename?: string | undefined;
+            active?: boolean | undefined;
+            role?: number | undefined;
+        }>]>;
+        method: "POST";
+        path: "/record/:storage_id";
+        headers: z.ZodObject<{
+            authorization: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            authorization?: string | undefined;
+        }, {
+            authorization?: string | undefined;
+        }>;
+        responses: {
+            200: z.ZodType<null, z.ZodTypeDef, null>;
+            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";
+            }>;
+            403: z.ZodObject<{
+                code: z.ZodType<"FORBIDDEN", z.ZodTypeDef, "FORBIDDEN">;
+                error: z.ZodType<"Forbidden", z.ZodTypeDef, "Forbidden">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "FORBIDDEN";
+                name: "APIError";
+                error: "Forbidden";
+            }, {
+                code: "FORBIDDEN";
+                name: "APIError";
+                error: "Forbidden";
+            }>;
+            404: z.ZodObject<{
+                code: z.ZodType<"NOT_FOUND", z.ZodTypeDef, "NOT_FOUND">;
+                error: z.ZodType<"Record not found", z.ZodTypeDef, "Record not found">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "NOT_FOUND";
+                name: "APIError";
+                error: "Record not found";
+            }, {
+                code: "NOT_FOUND";
+                name: "APIError";
+                error: "Record not found";
+            }>;
+            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";
+        path: "/record/:storage_id";
+        headers: z.ZodObject<{
+            authorization: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            authorization?: string | undefined;
+        }, {
+            authorization?: string | undefined;
+        }>;
+        responses: {
+            200: z.ZodType<null, z.ZodTypeDef, null>;
+            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";
+            }>;
+            403: z.ZodObject<{
+                code: z.ZodType<"FORBIDDEN", z.ZodTypeDef, "FORBIDDEN">;
+                error: z.ZodType<"Forbidden", z.ZodTypeDef, "Forbidden">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "FORBIDDEN";
+                name: "APIError";
+                error: "Forbidden";
+            }, {
+                code: "FORBIDDEN";
+                name: "APIError";
+                error: "Forbidden";
+            }>;
+            404: z.ZodObject<{
+                code: z.ZodType<"NOT_FOUND", z.ZodTypeDef, "NOT_FOUND">;
+                error: z.ZodType<"Record not found", z.ZodTypeDef, "Record not found">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "NOT_FOUND";
+                name: "APIError";
+                error: "Record not found";
+            }, {
+                code: "NOT_FOUND";
+                name: "APIError";
+                error: "Record not found";
+            }>;
+            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/{src/contract/record.ts → dist/contract/record.js}

@@ -1,82 +1,71 @@
-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()),
-        },
-    },
-});
+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()),
+        },
+    },
+});