├── index.js
├── .gitignore
├── tsconfig.json
├── package.json
├── README.md
├── test.ts
└── index.d.ts


/index.js:
--------------------------------------------------------------------------------
1 | module.exports = require("joi");
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .vscode/
2 | build/
3 | node_modules/
4 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "compilerOptions": {
 3 |         "declaration": true,
 4 |         "lib": ["es2018"],
 5 |         "module": "commonjs",
 6 |         "moduleResolution": "node",
 7 |         "noFallthroughCasesInSwitch": true,
 8 |         "noImplicitReturns": true,
 9 |         "outDir": "./build/",
10 |         "rootDir": "./",
11 |         "sourceMap": true,
12 |         "strict": true,
13 |         "target": "es2018"
14 |     },
15 |     "include": ["index.d.ts", "test.ts"]
16 | }
17 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "types-joi",
 3 |   "version": "2.1.0",
 4 |   "description": "TypeScript definitions for joi (Object schema description language and validator for JavaScript objects) https://joi.dev/",
 5 |   "keywords": [
 6 |     "ts",
 7 |     "typescript",
 8 |     "types",
 9 |     "validation",
10 |     "joi"
11 |   ],
12 |   "main": "index.js",
13 |   "types": "index",
14 |   "typeScriptVersion": "3.4.1",
15 |   "files": [
16 |     "index.d.ts",
17 |     "index.js"
18 |   ],
19 |   "scripts": {
20 |     "test": "tsc"
21 |   },
22 |   "author": "maghis",
23 |   "license": "ISC",
24 |   "devDependencies": {
25 |     "@types/node": "14.14.20",
26 |     "typescript": "4.1.3"
27 |   }
28 | }
29 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # types-joi
 2 | 
 3 | TypeScript definitions for joi (Object schema description language and validator for JavaScript objects) https://joi.dev/
 4 | 
 5 | # Getting started
 6 | 
 7 | Install `joi` and `types-joi`:
 8 | 
 9 | ```
10 | npm i joi types-joi
11 | ```
12 | 
13 | Use it:
14 | 
15 | ```ts
16 | import * as joi from "types-joi";
17 | import { InterfaceFrom } from "types-joi";
18 | 
19 | const messageSchema = joi.object({
20 |     status: joi.number().required(),
21 |     body: joi.string()
22 | }).required();
23 | 
24 | type Message = InterfaceFrom<typeof messageSchema>;
25 | 
26 | function processMessage(message: Message) {
27 |     if (message.body) message.body.length;
28 | }
29 | 
30 | const validatedMessage = joi.attempt({ some: "value" }, messageSchema);
31 | 
32 | processMessage(validatedMessage);
33 | ```
34 | 


--------------------------------------------------------------------------------
/test.ts:
--------------------------------------------------------------------------------
 1 | import * as joi from "types-joi";
 2 | import { InterfaceFrom } from "types-joi";
 3 | 
 4 | const schema = joi
 5 |     .object({
 6 |         test: joi
 7 |             .string()
 8 |             .required()
 9 |             .default("baz")
10 |             .valid("baz" as const, "bar" as const),
11 |         val: joi.number().optional(),
12 |         inner: joi
13 |             .object({
14 |                 a: joi.string(),
15 |                 b: joi.number()
16 |             })
17 |             .required(),
18 |         values: joi
19 |             .array()
20 |             .required()
21 |             .items(joi.string().required()),
22 |         buf: joi.binary().required(),
23 |         allowNullButRequired: joi.string().allow(null).required(),
24 |     })
25 |     .required();
26 | 
27 | type SchemaInterface = InterfaceFrom<typeof schema>;
28 | 
29 | const stringArray = joi.array().items(joi.string());
30 | 
31 | const either = joi.alternatives([joi.string(), joi.number()]).required();
32 | 
33 | const test = joi
34 |     .number()
35 |     .optional()
36 |     .required();
37 | 
38 | const metricsApiSchema = joi
39 |     .object({
40 |         field: joi.number().required(),
41 |         stringish: joi.string()
42 |     })
43 |     .required();
44 | 
45 | type Matching = InterfaceFrom<typeof metricsApiSchema>;
46 | 
47 | const aString = joi.string().required();
48 | const len = aString.length;
49 | 
50 | function handleObj(obj: Matching) {
51 |     const test: number = obj.field
52 | }
53 | type PickNot<T, K extends keyof T> = {
54 |     [P in keyof T]: P extends K ? undefined : T[P];
55 | };
56 | 
57 | const sample = {
58 |     hello: "test",
59 |     bla: true
60 | };
61 | 
62 | type SampleType = typeof sample;
63 | 
64 | const someObject = undefined as any as PickNot<SampleType, "hello">;
65 | const someOther = joi.object().pattern(/test/, joi.string().required());
66 | const thing = joi.attempt(undefined, someOther)["test"];
67 | 
68 | (async () => {
69 |     const res = await schema.validate({ test: "aaa" });
70 | 
71 |     const foo = res.test;
72 | 
73 |     if (foo !== "bar") {
74 |         const bar: "baz" = foo;
75 |     }
76 | 
77 |     const buf: Buffer = joi.attempt(undefined, schema).buf;
78 | 
79 |     const result: Matching = joi.attempt(undefined, metricsApiSchema);
80 |     const someNumber: number = result.field;
81 | })();
82 | 
83 | const emptyObj = joi.object();
84 | 


--------------------------------------------------------------------------------
/index.d.ts:
--------------------------------------------------------------------------------
  1 | type PickNot<T, K extends keyof T> = {
  2 |     [P in keyof T]: P extends K ? undefined : T[P];
  3 | };
  4 | 
  5 | type DictObj<T> = { [key: string]: T };
  6 | 
  7 | declare module "types-joi" {
  8 |     type Callback<T> = ((err: null, value: T) => void) | ((err: ValidationError, value: null) => void);
  9 | 
 10 |     interface JoiError {
 11 |         readonly message: string;
 12 |         readonly path: any[];
 13 |         readonly type: string;
 14 |         readonly context: any;
 15 |     }
 16 | 
 17 |     interface ValidationError extends Error {
 18 |         readonly name: "ValidationError";
 19 |         readonly isJoi: true;
 20 |         readonly details: JoiError[];
 21 |         annotate(stripColors?: boolean): string;
 22 |         readonly _object: any;
 23 |     }
 24 | 
 25 |     type DefaultMethod<T> = (context: any) => T;
 26 | 
 27 |     interface ValidateFail<T> extends Promise<T> {
 28 |         readonly error: ValidationError;
 29 |         readonly value: any;
 30 |     }
 31 | 
 32 |     interface ValidateSuccess<T> extends Promise<T> {
 33 |         readonly error: null;
 34 |         readonly value: T;
 35 |     }
 36 | 
 37 |     type ValidateResult<T> = ValidateSuccess<T> | ValidateFail<T>;
 38 | 
 39 |     type TypeName<T> =
 40 |         T extends string ? "string" :
 41 |         T extends number ? "number" :
 42 |         T extends boolean ? "boolean" :
 43 |         T extends undefined ? "undefined" :
 44 |         T extends Function ? "function" :
 45 |         "object";
 46 | 
 47 |     interface BaseSchema<T> {
 48 |         readonly schemaType: TypeName<NonNullable<T>>;
 49 |         validate(value: any, options?: any, callback?: any): ValidateResult<T>;
 50 |     }
 51 | 
 52 |     interface Extensions<T> {
 53 |         description(desc: string): T;
 54 |         notes(notes: string[]): T;
 55 |         tags(tags: string[]): T;
 56 |         meta(meta: any): T;
 57 |         example(...values: any[]): T;
 58 |         unit(name: string): T;
 59 |         label(name: string): T;
 60 |         options(options: any): T;
 61 |         strict(isStrict: boolean): T;
 62 |         error(err: any, options: any): T;
 63 |         describe(): any;
 64 |     }
 65 | 
 66 |     interface AnySchema<T> extends BaseSchema<T>, Extensions<Schema<T>> {
 67 |         allow<U>(...values: readonly U[]): Schema<T | U>;
 68 | 
 69 |         valid<U>(...values: readonly U[]): Schema<U>;
 70 | 
 71 |         required(): Schema<T extends undefined ? never : T>;
 72 |         optional(): Schema<T | undefined>;
 73 | 
 74 |         forbidden(): Schema<never>;
 75 |         strip(): Schema<never>;
 76 | 
 77 |         default(value: T, description?: string): Schema<NonNullable<T>>;
 78 |         default(value: DefaultMethod<T> & { description: string }): Schema<T>;
 79 |         default(value: DefaultMethod<T>, description: string): Schema<T>;
 80 | 
 81 |         // // concat<U>(schema: Schema<U>): Schema<T | U>;
 82 |         // // when(condition, options)
 83 | 
 84 |         // raw(isRaw: boolean): Schema<any>;
 85 |         // empty(schema: T | Schema<T>): Schema<T | undefined>;
 86 |         // empty(): Schema<NonNullable<T>>;
 87 |     }
 88 | 
 89 |     type ArrayComparator<T> = (a: T, b: T) => boolean;
 90 |     interface ArrayUniqueOptions {
 91 |         ignoreUndefined: boolean;
 92 |     }
 93 | 
 94 |     interface ArraySchema<T = any[] | undefined> extends AnySchema<T> {
 95 |         // sparse([enabled])
 96 |         // single([enabled])
 97 |         items<U>(schema: Schema<U>): Schema<NonNullable<U>[] | undefined>;
 98 |         // ordered(type)
 99 | 
100 |         min(limit: number): Schema<T>;
101 |         max(limit: number): Schema<T>;
102 |         length(limit: number): Schema<T>;
103 |         unique(comparator: ArrayComparator<T> | string, options: ArrayUniqueOptions): Schema<T>;
104 |         // has(schema)
105 |     }
106 | 
107 |     interface BooleanSchema<T> extends AnySchema<T> {
108 |         truthy(value: any | any[]): Schema<T>;
109 |         falsy(value: any | any[]): Schema<T>;
110 |         empty(value: any): Schema<T | undefined>;
111 |         insensitive(enabled?: boolean): Schema<T>;
112 |     }
113 | 
114 |     interface BinarySchema<T> extends AnySchema<T> {
115 |         encoding(encoding: string): Schema<T>;
116 |         min(limit: number): Schema<T>;
117 |         max(limit: number): Schema<T>;
118 |         length(limit: number): Schema<T>;
119 |     }
120 | 
121 |     type DateType = Date | "now" | number | string;
122 |     interface DateSchema<T> extends AnySchema<T> {
123 |         min(date: DateType): Schema<T>;
124 |         max(date: DateType): Schema<T>;
125 |         greater(date: DateType): Schema<T>;
126 |         less(date: DateType): Schema<T>;
127 |         iso(): Schema<T>;
128 |         timestamp(type?: "javascript" | "unix"): Schema<T>;
129 |     }
130 | 
131 |     interface NumberSchema<T> extends AnySchema<T> {
132 |         unsafe(enabled?: boolean): Schema<T>;
133 |         min(limit: number): Schema<T>;
134 |         max(limit: number): Schema<T>;
135 |         greater(limit: number): Schema<T>;
136 |         less(limit: number): Schema<T>;
137 |         integer(): Schema<T>;
138 |         precision(limit: number): Schema<T>;
139 |         multiple(base: number): Schema<T>;
140 |         positive(): Schema<T>;
141 |         negative(): Schema<T>;
142 |         port(): Schema<T>;
143 |     }
144 | 
145 |     interface RegexOptions {
146 |         name?: string;
147 |         invert?: boolean;
148 |     }
149 | 
150 |     interface StringSchema<T> extends AnySchema<T> {
151 |         insensitive(): Schema<T>;
152 |         min(limit: number, encoding?: string): Schema<T>;
153 |         max(limit: number, encoding?: string): Schema<T>;
154 |         truncate(enabled?: boolean): Schema<T>;
155 |         creditCard(): Schema<T>;
156 |         length(limit: number, encoding?: boolean): Schema<T>;
157 |         regex(pattern: RegExp, name?: string): Schema<T>;
158 |         regex(pattern: RegExp, options?: RegexOptions): Schema<T>;
159 |         replace(pattern: RegExp | string, replacement: string): Schema<T>;
160 |         alphanum(): Schema<T>;
161 |         token(): Schema<T>;
162 |         email(options?: any): Schema<T>;
163 |         ip(options?: any): Schema<T>;
164 |         uri(options?: any): Schema<T>;
165 |         guid(): Schema<T>;
166 |         hex(options?: any): Schema<T>;
167 |         base64(options?: any): Schema<T>;
168 |         dataUri(options?: any): Schema<T>;
169 |         hostname(): Schema<T>;
170 |         normalize(options?: any): Schema<T>;
171 |         lowercase(): Schema<T>;
172 |         uppercase(): Schema<T>;
173 |         trim(enabled?: boolean): Schema<T>;
174 |         isoDate(): Schema<T>;
175 |     }
176 | 
177 |     type SchemaMap<T> = {
178 |         [P in keyof T]: Schema<T[P]>
179 |     };
180 | 
181 |     interface ObjectSchema<T> extends AnySchema<T> {
182 |         keys<U>(schema: SchemaMap<U>): Schema<T & U>;
183 |         append<U>(schema: SchemaMap<U>): Schema<T & U>;
184 |         min(limit: number): Schema<T>;
185 |         max(limit: number): Schema<T>;
186 |         length(limit: number): Schema<T>;
187 |         pattern<U>(pattern: RegExp | Schema<string | undefined>, schema: Schema<U>): Schema<DictObj<U | undefined>>;
188 |         // and(peers): Schema<T>;
189 |         // nand(peers): Schema<T>;
190 |         // or(peers): Schema<T>;
191 |         // xor(peers): Schema<T>;
192 |         // oxor(...peers): Schema<T>;
193 |         // with(key, peers): Schema<T>;
194 |         // without(key, peers): Schema<T>;
195 |         // rename<U extends keyof T, V extends string>(from: U, to: V): Schema<PickNot<T, U>>;
196 |         // assert(ref, schema, [message]): Schema<T>;
197 |         unknown(allow: true): Schema<T & { [key: string]: any }>;
198 |         // type(constructor, [name]): Schema<T>;
199 |         // schema(): Schema<T>;
200 |         // requiredKeys(children): Schema<T>;
201 |         // optionalKeys(children): Schema<T>;
202 |         // forbiddenKeys(children): Schema<T>;
203 |     }
204 | 
205 |     type Schema<T> =
206 |         NonNullable<T> extends any[] ? ArraySchema<T> :
207 |         NonNullable<T> extends boolean ? BooleanSchema<T> :
208 |         NonNullable<T> extends Buffer ? BinarySchema<T> :
209 |         NonNullable<T> extends Date ? DateSchema<T> :
210 |         NonNullable<T> extends number ? NumberSchema<T> :
211 |         NonNullable<T> extends string ? StringSchema<T> :
212 |         NonNullable<T> extends {} ? ObjectSchema<T> :
213 |         AnySchema<T>;
214 | 
215 |     function attempt<T>(value: any, schema: BaseSchema<T>, message?: string | Error): T;
216 |     type InterfaceFrom<T extends BaseSchema<any>> = T extends BaseSchema<infer U> ? U : never;
217 | 
218 |     function any(): Schema<unknown | undefined>;
219 |     function array(): Schema<unknown[] | undefined>;
220 |     function boolean(): Schema<boolean | undefined>;
221 |     function binary(): Schema<Buffer | undefined>;
222 |     function date(): Schema<Date | undefined>;
223 |     function number(): Schema<number | undefined>;
224 |     function string(): Schema<string | undefined>;
225 |     function object<T>(): Schema<{} | undefined>;
226 |     function object<T>(map: SchemaMap<T>): Schema<T | undefined>;
227 |     function alternatives<A, B>(schemas: [Schema<A>, Schema<B>]): Schema<A | B>;
228 |     function alternatives<A, B, C>(schemas: [Schema<A>, Schema<B>, Schema<C>]): Schema<A | B | C>;
229 |     function alternatives<A, B, C, D>(schemas: [Schema<A>, Schema<B>, Schema<C>, Schema<D>]): Schema<A | B | C | D>;
230 | }
231 | 


--------------------------------------------------------------------------------