11720602297

Committed 07 Nov 2024 09:54AM UTC coverage: 90.837% (-0.07%) from 90.909%

Build # 11720602297

Build Type

push

github

Committed by

web-flow

Commit Message

fix: prevent nested validations from throwing (#674)

Co-authored-by: acarchi <acarchi@b2pweb.com>

Run Details

242 of 288 branches covered (84.03%)

Branch coverage included in aggregate %.

8 of 8 new or added lines in 1 file covered. (100.0%)

2 existing lines in 1 file now uncovered.

789 of 847 relevant lines covered (93.15%)

104.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.21

/src/i18n.module.ts

import {
  DynamicModule,
  Global,
  Inject,
  Logger,
  MiddlewareConsumer,
  Module,
  OnModuleDestroy,
  Provider,
} from '@nestjs/common';
import {
  I18N_OPTIONS,
  I18N_TRANSLATIONS,
  I18N_LANGUAGES,
  I18N_RESOLVERS,
  I18N_LOADER_OPTIONS,
  I18N_LANGUAGES_SUBJECT,
  I18N_TRANSLATIONS_SUBJECT,
} from './i18n.constants';
import { I18nService } from './services/i18n.service';
import {
  I18nAsyncOptions,
  I18nOptions,
  I18nOptionsFactory,
  I18nOptionResolver,
} from './interfaces/i18n-options.interface';
import {
  ValueProvider,
  ClassProvider,
  OnModuleInit,
  NestModule,
} from '@nestjs/common';
import { I18nLanguageInterceptor } from './interceptors/i18n-language.interceptor';
import { APP_INTERCEPTOR, HttpAdapterHost } from '@nestjs/core';
import { getI18nResolverOptionsToken } from './decorators';
import {
  isNestMiddleware,
  shouldResolve,
  usingFastify,
  mergeDeep,
} from './utils';
import { I18nTranslation } from './interfaces/i18n-translation.interface';
import { I18nLoader } from './loaders/i18n.loader';
import { Observable, BehaviorSubject, Subject, takeUntil } from 'rxjs';
import * as format from 'string-format';
import { I18nJsonLoader } from './loaders';
import { I18nMiddleware } from './middlewares/i18n.middleware';
import * as fs from 'fs';
import * as path from 'path';
export const logger = new Logger('I18nService');

const defaultOptions: Partial<I18nOptions> = {
  resolvers: [],
  formatter: format,
  logging: true,
  throwOnMissingKey: false,
  loader: I18nJsonLoader,
};

@Global()
@Module({})
export class I18nModule implements OnModuleInit, OnModuleDestroy, NestModule {
  private unsubscribe = new Subject<void>();

  constructor(
    private readonly i18n: I18nService,
    @Inject(I18N_TRANSLATIONS)
    private translations: Observable<I18nTranslation>,
    @Inject(I18N_OPTIONS) private readonly i18nOptions: I18nOptions,
    private adapter: HttpAdapterHost,
  ) {}

  async onModuleInit() {
    // makes sure languages & translations are loaded before application loads
    await this.i18n.refresh();

    // Register handlebars helper
    if (this.i18nOptions.viewEngine == 'hbs') {
      try {
        const hbs = await import('hbs');
        hbs.registerHelper('t', this.i18n.hbsHelper);
        logger.log('Handlebars helper registered');
      } catch (e) {
        logger.error('hbs module failed to load', e);
      }
    }

    if (['pug', 'ejs'].includes(this.i18nOptions.viewEngine)) {
      const app = this.adapter.httpAdapter.getInstance();
      app.locals['t'] = (key: string, lang: any, args: any) => {
        return this.i18n.t(key, { lang, args });
      };
    }

    if (!!this.i18nOptions.typesOutputPath) {
      try {
        const ts = await import('./utils/typescript');

        this.translations
          .pipe(takeUntil(this.unsubscribe))
          .subscribe(async (t) => {
            logger.log('Checking translation changes');
            const object = Object.keys(t).reduce(
              (result, key) => mergeDeep(result, t[key]),
              {},
            );

            const rawContent = await ts.createTypesFile(object);

            if (!rawContent) {
              return;
            }

            const outputFile = ts.annotateSourceCode(rawContent);

            fs.mkdirSync(path.dirname(this.i18nOptions.typesOutputPath), {
              recursive: true,
            });
            let currentFileContent = null;
            try {
              currentFileContent = fs.readFileSync(
                this.i18nOptions.typesOutputPath,
                'utf8',
              );
            } catch (err) {
              logger.error(err);
            }
            if (currentFileContent != outputFile) {
              fs.writeFileSync(this.i18nOptions.typesOutputPath, outputFile);
              logger.log(
                `Types generated in: ${this.i18nOptions.typesOutputPath}.
                Please also add it to ignore files of your linter and formatter to avoid linting and formatting it
                `,
              );
            } else {
              logger.log('No changes detected');
            }
          });
      } catch (_) {
        // NOOP: typescript package not found
      }
    }
  }

  onModuleDestroy() {
    this.unsubscribe.complete();
  }

  configure(consumer: MiddlewareConsumer) {
    if (this.i18nOptions.disableMiddleware) return;

    consumer
      .apply(I18nMiddleware)
      .forRoutes(
        isNestMiddleware(consumer) && usingFastify(consumer) ? '(.*)' : '*',
      );
  }

  static forRoot(options: I18nOptions): DynamicModule {
    options = this.sanitizeI18nOptions(options);

    const i18nLanguagesSubject = new BehaviorSubject<string[]>([]);
    const i18nTranslationSubject = new BehaviorSubject<I18nTranslation>({});

    const i18nOptions: ValueProvider = {
      provide: I18N_OPTIONS,
      useValue: options,
    };

    const i18nLoaderProvider: ClassProvider = {
      provide: I18nLoader,
      useClass: options.loader,
    };

    const i18nLoaderOptionsProvider: ValueProvider = {
      provide: I18N_LOADER_OPTIONS,
      useValue: options.loaderOptions,
    };

    const i18nLanguagesSubjectProvider: ValueProvider = {
      provide: I18N_LANGUAGES_SUBJECT,
      useValue: i18nLanguagesSubject,
    };

    const i18nTranslationSubjectProvider: ValueProvider = {
      provide: I18N_TRANSLATIONS_SUBJECT,
      useValue: i18nTranslationSubject,
    };

    const translationsProvider = {
      provide: I18N_TRANSLATIONS,
      useFactory: async (
        loader: I18nLoader,
      ): Promise<Observable<I18nTranslation>> => {
        try {
          const translation = await loader.load();
          if (translation instanceof Observable) {
            translation.subscribe(i18nTranslationSubject);
          } else {
            i18nTranslationSubject.next(translation);
          }
        } catch (e) {
          logger.error('parsing translation error', e);
        }
        return i18nTranslationSubject.asObservable();
      },
      inject: [I18nLoader],
    };

    const languagesProvider = {
      provide: I18N_LANGUAGES,
      useFactory: async (loader: I18nLoader): Promise<Observable<string[]>> => {
        try {
          const languages = await loader.languages();
          if (languages instanceof Observable) {
            languages.subscribe(i18nLanguagesSubject);
          } else {
            i18nLanguagesSubject.next(languages);
          }
        } catch (e) {
          logger.error('parsing translation error', e);
        }
        return i18nLanguagesSubject.asObservable();
      },
      inject: [I18nLoader],
    };

    const resolversProvider = {
      provide: I18N_RESOLVERS,
      useValue: options.resolvers || [],
    };

    return {
      module: I18nModule,
      providers: [
        { provide: Logger, useValue: logger },
        {
          provide: APP_INTERCEPTOR,
          useClass: I18nLanguageInterceptor,
        },
        I18nService,
        i18nOptions,
        translationsProvider,
        languagesProvider,
        resolversProvider,
        i18nLoaderProvider,
        i18nLoaderOptionsProvider,
        i18nLanguagesSubjectProvider,
        i18nTranslationSubjectProvider,
        ...this.createResolverProviders(options.resolvers),
      ],
      exports: [I18N_OPTIONS, I18N_RESOLVERS, I18nService, languagesProvider],
    };
  }

  static forRootAsync(options: I18nAsyncOptions): DynamicModule {
    options = this.sanitizeI18nOptions(options);

    const asyncOptionsProvider = this.createAsyncOptionsProvider(options);
    const asyncTranslationProvider = this.createAsyncTranslationProvider();
    const asyncLanguagesProvider = this.createAsyncLanguagesProvider();
    const asyncLoaderOptionsProvider = this.createAsyncLoaderOptionsProvider();

    const i18nLanguagesSubject = new BehaviorSubject<string[]>([]);
    const i18nTranslationSubject = new BehaviorSubject<I18nTranslation>({});

    const resolversProvider: ValueProvider = {
      provide: I18N_RESOLVERS,
      useValue: options.resolvers || [],
    };

    const i18nLoaderProvider: ClassProvider<I18nLoader> = {
      provide: I18nLoader,
      useClass: options.loader,
    };

    const i18nLanguagesSubjectProvider: ValueProvider = {
      provide: I18N_LANGUAGES_SUBJECT,
      useValue: i18nLanguagesSubject,
    };

    const i18nTranslationSubjectProvider: ValueProvider = {
      provide: I18N_TRANSLATIONS_SUBJECT,
      useValue: i18nTranslationSubject,
    };

    return {
      module: I18nModule,
      imports: options.imports || [],
      providers: [
        { provide: Logger, useValue: logger },
        {
          provide: APP_INTERCEPTOR,
          useClass: I18nLanguageInterceptor,
        },
        asyncOptionsProvider,
        asyncTranslationProvider,
        asyncLanguagesProvider,
        asyncLoaderOptionsProvider,
        I18nService,
        resolversProvider,
        i18nLoaderProvider,
        i18nLanguagesSubjectProvider,
        i18nTranslationSubjectProvider,
        ...this.createResolverProviders(options.resolvers),
      ],
      exports: [
        I18N_OPTIONS,
        I18N_RESOLVERS,
        I18nService,
        asyncLanguagesProvider,
      ],
    };
  }

  private static createAsyncOptionsProvider(
    options: I18nAsyncOptions,
  ): Provider {
    if (options.useFactory) {
      return {
        provide: I18N_OPTIONS,
        useFactory: async (...args) => {
          return this.sanitizeI18nOptions(
            (await options.useFactory(...args)) as any,
          );
        },
        inject: options.inject || [],
      };
    }
    return {
      provide: I18N_OPTIONS,
      useFactory: async (optionsFactory: I18nOptionsFactory) =>
        this.sanitizeI18nOptions(
          (await optionsFactory.createI18nOptions()) as any,
        ),
      inject: [options.useClass || options.useExisting],
    };
  }

  private static createAsyncLoaderOptionsProvider(): Provider {
    return {
      provide: I18N_LOADER_OPTIONS,
      useFactory: async (options: I18nOptions): Promise<any> => {
        return this.sanitizeI18nOptions(options.loaderOptions);
      },
      inject: [I18N_OPTIONS],
    };
  }

  private static createAsyncTranslationProvider(): Provider {
    return {
      provide: I18N_TRANSLATIONS,
      useFactory: async (
        loader: I18nLoader,
        translationsSubject: BehaviorSubject<I18nTranslation>,
      ): Promise<Observable<I18nTranslation>> => {
        try {
          const translation = await loader.load();
          if (translation instanceof Observable) {
            translation.subscribe(translationsSubject);
          } else {
            translationsSubject.next(translation);
          }
        } catch (e) {
          logger.error('parsing translation error', e);
        }
        return translationsSubject.asObservable();
      },
      inject: [I18nLoader, I18N_TRANSLATIONS_SUBJECT],
    };
  }

  private static createAsyncLanguagesProvider(): Provider {
    return {
      provide: I18N_LANGUAGES,
      useFactory: async (
        loader: I18nLoader,
        languagesSubject: BehaviorSubject<string[]>,
      ): Promise<Observable<string[]>> => {
        try {
          const languages = await loader.languages();
          if (languages instanceof Observable) {
            languages.subscribe(languagesSubject);
          } else {
            languagesSubject.next(languages);
          }
        } catch (e) {
          logger.error('parsing translation error', e);
        }
        return languagesSubject.asObservable();
      },
      inject: [I18nLoader, I18N_LANGUAGES_SUBJECT],
    };
  }

  private static sanitizeI18nOptions<T = I18nOptions | I18nAsyncOptions>(
    options: T,
  ) {
    options = { ...defaultOptions, ...options };
    return options;
  }

  private static createResolverProviders(resolvers?: I18nOptionResolver[]) {
    if (!resolvers || resolvers.length === 0) {
      logger.error(
        `No resolvers provided! nestjs-i18n won't work properly, please follow the quick-start guide: https://nestjs-i18n.com/quick-start`,
      );
    }
    return (resolvers || [])
      .filter(shouldResolve)
      .reduce<Provider[]>((providers, r) => {
        if (r['use']) {
          const { use: resolver, options, ...rest } = r as any;
          const optionsToken = getI18nResolverOptionsToken(
            resolver as unknown as () => void,
          );
          providers.push({
            provide: resolver,
            useClass: resolver,
          });
          if (options) {
            (rest as any).useValue = options;
          }
          providers.push({
            provide: optionsToken,
            ...(rest as any),
          });
        } else {
          const optionsToken = getI18nResolverOptionsToken(
            r as unknown as () => void,
          );
          providers.push({
            provide: r,
            useClass: r,
            inject: [optionsToken],
          } as any);
          providers.push({
            provide: optionsToken,
            useFactory: () => undefined,
          });
        }

        return providers;
      }, []);
  }
}

1	import {	14✔
2	DynamicModule,
3	Global,
4	Inject,
5	Logger,
6	MiddlewareConsumer,
7	Module,
8	OnModuleDestroy,
9	Provider,
10	} from '@nestjs/common';
11	import {	14✔
12	I18N_OPTIONS,
13	I18N_TRANSLATIONS,
14	I18N_LANGUAGES,
15	I18N_RESOLVERS,
16	I18N_LOADER_OPTIONS,
17	I18N_LANGUAGES_SUBJECT,
18	I18N_TRANSLATIONS_SUBJECT,
19	} from './i18n.constants';
20	import { I18nService } from './services/i18n.service';	14✔
21	import {
22	I18nAsyncOptions,
23	I18nOptions,
24	I18nOptionsFactory,
25	I18nOptionResolver,
26	} from './interfaces/i18n-options.interface';
27	import {
28	ValueProvider,
29	ClassProvider,
30	OnModuleInit,
31	NestModule,
32	} from '@nestjs/common';
33	import { I18nLanguageInterceptor } from './interceptors/i18n-language.interceptor';	14✔
34	import { APP_INTERCEPTOR, HttpAdapterHost } from '@nestjs/core';	14✔
35	import { getI18nResolverOptionsToken } from './decorators';	14✔
36	import {	14✔
37	isNestMiddleware,
38	shouldResolve,
39	usingFastify,
40	mergeDeep,
41	} from './utils';
42	import { I18nTranslation } from './interfaces/i18n-translation.interface';
43	import { I18nLoader } from './loaders/i18n.loader';	14✔
44	import { Observable, BehaviorSubject, Subject, takeUntil } from 'rxjs';	14✔
45	import * as format from 'string-format';	14✔
46	import { I18nJsonLoader } from './loaders';	14✔
47	import { I18nMiddleware } from './middlewares/i18n.middleware';	14✔
48	import * as fs from 'fs';	14✔
49	import * as path from 'path';	14✔
50	export const logger = new Logger('I18nService');	14✔
51
52	const defaultOptions: Partial<I18nOptions> = {	14✔
53	resolvers: [],
54	formatter: format,
55	logging: true,
56	throwOnMissingKey: false,
57	loader: I18nJsonLoader,
58	};
59
60	@Global()
61	@Module({})
62	export class I18nModule implements OnModuleInit, OnModuleDestroy, NestModule {	14✔
63	private unsubscribe = new Subject<void>();	21✔
64
65	constructor(
66	private readonly i18n: I18nService,	21✔
67	@Inject(I18N_TRANSLATIONS)
68	private translations: Observable<I18nTranslation>,	21✔
69	@Inject(I18N_OPTIONS) private readonly i18nOptions: I18nOptions,	21✔
70	private adapter: HttpAdapterHost,	21✔
71	) {}
72
73	async onModuleInit() {
74	// makes sure languages & translations are loaded before application loads
75	await this.i18n.refresh();	10✔
76
77	// Register handlebars helper
78	if (this.i18nOptions.viewEngine == 'hbs') {	10✔
79	try {	1✔
80	const hbs = await import('hbs');	2✔
81	hbs.registerHelper('t', this.i18n.hbsHelper);	1✔
82	logger.log('Handlebars helper registered');	1✔
83	} catch (e) {
84	logger.error('hbs module failed to load', e);	×
85	}
86	}
87
88	if (['pug', 'ejs'].includes(this.i18nOptions.viewEngine)) {	10✔
89	const app = this.adapter.httpAdapter.getInstance();	2✔
90	app.locals['t'] = (key: string, lang: any, args: any) => {	2✔
91	return this.i18n.t(key, { lang, args });	11✔
92	};
93	}
94
95	if (!!this.i18nOptions.typesOutputPath) {	10✔
96	try {	1✔
97	const ts = await import('./utils/typescript');	2✔
98
99	this.translations	1✔
100	.pipe(takeUntil(this.unsubscribe))
101	.subscribe(async (t) => {
102	logger.log('Checking translation changes');	1✔
103	const object = Object.keys(t).reduce(	1✔
104	(result, key) => mergeDeep(result, t[key]),	10✔
105	{},
106	);
107
108	const rawContent = await ts.createTypesFile(object);	1✔
109
110	if (!rawContent) {	1!
111	return;	×
112	}
113
114	const outputFile = ts.annotateSourceCode(rawContent);	1✔
115
116	fs.mkdirSync(path.dirname(this.i18nOptions.typesOutputPath), {	1✔
117	recursive: true,
118	});
119	let currentFileContent = null;	1✔
120	try {	1✔
121	currentFileContent = fs.readFileSync(	1✔
122	this.i18nOptions.typesOutputPath,
123	'utf8',
124	);
125	} catch (err) {
126	logger.error(err);	×
127	}
128	if (currentFileContent != outputFile) {	1!
UNCOV 129	fs.writeFileSync(this.i18nOptions.typesOutputPath, outputFile);	×
UNCOV 130	logger.log(	×
131	`Types generated in: ${this.i18nOptions.typesOutputPath}.
132	Please also add it to ignore files of your linter and formatter to avoid linting and formatting it
133	`,
134	);
135	} else {
136	logger.log('No changes detected');	1✔
137	}
138	});
139	} catch (_) {
140	// NOOP: typescript package not found
141	}
142	}
143	}
144
145	onModuleDestroy() {
146	this.unsubscribe.complete();	10✔
147	}
148
149	configure(consumer: MiddlewareConsumer) {
150	if (this.i18nOptions.disableMiddleware) return;	10✔
151
152	consumer	9✔
153	.apply(I18nMiddleware)
154	.forRoutes(
155	isNestMiddleware(consumer) && usingFastify(consumer) ? '(.)' : '',	27✔
156	);
157	}
158
159	static forRoot(options: I18nOptions): DynamicModule {
160	options = this.sanitizeI18nOptions(options);	18✔
161
162	const i18nLanguagesSubject = new BehaviorSubject<string[]>([]);	18✔
163	const i18nTranslationSubject = new BehaviorSubject<I18nTranslation>({});	18✔
164
165	const i18nOptions: ValueProvider = {	18✔
166	provide: I18N_OPTIONS,
167	useValue: options,
168	};
169
170	const i18nLoaderProvider: ClassProvider = {	18✔
171	provide: I18nLoader,
172	useClass: options.loader,
173	};
174
175	const i18nLoaderOptionsProvider: ValueProvider = {	18✔
176	provide: I18N_LOADER_OPTIONS,
177	useValue: options.loaderOptions,
178	};
179
180	const i18nLanguagesSubjectProvider: ValueProvider = {	18✔
181	provide: I18N_LANGUAGES_SUBJECT,
182	useValue: i18nLanguagesSubject,
183	};
184
185	const i18nTranslationSubjectProvider: ValueProvider = {	18✔
186	provide: I18N_TRANSLATIONS_SUBJECT,
187	useValue: i18nTranslationSubject,
188	};
189
190	const translationsProvider = {	18✔
191	provide: I18N_TRANSLATIONS,
192	useFactory: async (
193	loader: I18nLoader,
194	): Promise<Observable<I18nTranslation>> => {
195	try {	18✔
196	const translation = await loader.load();	18✔
197	if (translation instanceof Observable) {	18✔
198	translation.subscribe(i18nTranslationSubject);	1✔
199	} else {
200	i18nTranslationSubject.next(translation);	17✔
201	}
202	} catch (e) {
203	logger.error('parsing translation error', e);	×
204	}
205	return i18nTranslationSubject.asObservable();	18✔
206	},
207	inject: [I18nLoader],
208	};
209
210	const languagesProvider = {	18✔
211	provide: I18N_LANGUAGES,
212	useFactory: async (loader: I18nLoader): Promise<Observable<string[]>> => {
213	try {	18✔
214	const languages = await loader.languages();	18✔
215	if (languages instanceof Observable) {	18✔
216	languages.subscribe(i18nLanguagesSubject);	1✔
217	} else {
218	i18nLanguagesSubject.next(languages);	17✔
219	}
220	} catch (e) {
221	logger.error('parsing translation error', e);	×
222	}
223	return i18nLanguagesSubject.asObservable();	18✔
224	},
225	inject: [I18nLoader],
226	};
227
228	const resolversProvider = {	18✔
229	provide: I18N_RESOLVERS,
230	useValue: options.resolvers \|\| [],	18!
231	};
232
233	return {	18✔
234	module: I18nModule,
235	providers: [
236	{ provide: Logger, useValue: logger },
237	{
238	provide: APP_INTERCEPTOR,
239	useClass: I18nLanguageInterceptor,
240	},
241	I18nService,
242	i18nOptions,
243	translationsProvider,
244	languagesProvider,
245	resolversProvider,
246	i18nLoaderProvider,
247	i18nLoaderOptionsProvider,
248	i18nLanguagesSubjectProvider,
249	i18nTranslationSubjectProvider,
250	...this.createResolverProviders(options.resolvers),
251	],
252	exports: [I18N_OPTIONS, I18N_RESOLVERS, I18nService, languagesProvider],
253	};
254	}
255
256	static forRootAsync(options: I18nAsyncOptions): DynamicModule {
257	options = this.sanitizeI18nOptions(options);	3✔
258
259	const asyncOptionsProvider = this.createAsyncOptionsProvider(options);	3✔
260	const asyncTranslationProvider = this.createAsyncTranslationProvider();	3✔
261	const asyncLanguagesProvider = this.createAsyncLanguagesProvider();	3✔
262	const asyncLoaderOptionsProvider = this.createAsyncLoaderOptionsProvider();	3✔
263
264	const i18nLanguagesSubject = new BehaviorSubject<string[]>([]);	3✔
265	const i18nTranslationSubject = new BehaviorSubject<I18nTranslation>({});	3✔
266
267	const resolversProvider: ValueProvider = {	3✔
268	provide: I18N_RESOLVERS,
269	useValue: options.resolvers \|\| [],	3!
270	};
271
272	const i18nLoaderProvider: ClassProvider<I18nLoader> = {	3✔
273	provide: I18nLoader,
274	useClass: options.loader,
275	};
276
277	const i18nLanguagesSubjectProvider: ValueProvider = {	3✔
278	provide: I18N_LANGUAGES_SUBJECT,
279	useValue: i18nLanguagesSubject,
280	};
281
282	const i18nTranslationSubjectProvider: ValueProvider = {	3✔
283	provide: I18N_TRANSLATIONS_SUBJECT,
284	useValue: i18nTranslationSubject,
285	};
286
287	return {	3✔
288	module: I18nModule,
289	imports: options.imports \|\| [],	5✔
290	providers: [
291	{ provide: Logger, useValue: logger },
292	{
293	provide: APP_INTERCEPTOR,
294	useClass: I18nLanguageInterceptor,
295	},
296	asyncOptionsProvider,
297	asyncTranslationProvider,
298	asyncLanguagesProvider,
299	asyncLoaderOptionsProvider,
300	I18nService,
301	resolversProvider,
302	i18nLoaderProvider,
303	i18nLanguagesSubjectProvider,
304	i18nTranslationSubjectProvider,
305	...this.createResolverProviders(options.resolvers),
306	],
307	exports: [
308	I18N_OPTIONS,
309	I18N_RESOLVERS,
310	I18nService,
311	asyncLanguagesProvider,
312	],
313	};
314	}
315
316	private static createAsyncOptionsProvider(
317	options: I18nAsyncOptions,
318	): Provider {
319	if (options.useFactory) {	3✔
320	return {	3✔
321	provide: I18N_OPTIONS,
322	useFactory: async (...args) => {
323	return this.sanitizeI18nOptions(	3✔
324	(await options.useFactory(...args)) as any,
325	);
326	},
327	inject: options.inject \|\| [],	5✔
328	};
329	}
330	return {	×
331	provide: I18N_OPTIONS,
332	useFactory: async (optionsFactory: I18nOptionsFactory) =>
333	this.sanitizeI18nOptions(	×
334	(await optionsFactory.createI18nOptions()) as any,
335	),
336	inject: [options.useClass \|\| options.useExisting],	×
337	};
338	}
339
340	private static createAsyncLoaderOptionsProvider(): Provider {
341	return {	3✔
342	provide: I18N_LOADER_OPTIONS,
343	useFactory: async (options: I18nOptions): Promise<any> => {
344	return this.sanitizeI18nOptions(options.loaderOptions);	3✔
345	},
346	inject: [I18N_OPTIONS],
347	};
348	}
349
350	private static createAsyncTranslationProvider(): Provider {
351	return {	3✔
352	provide: I18N_TRANSLATIONS,
353	useFactory: async (
354	loader: I18nLoader,
355	translationsSubject: BehaviorSubject<I18nTranslation>,
356	): Promise<Observable<I18nTranslation>> => {
357	try {	3✔
358	const translation = await loader.load();	3✔
359	if (translation instanceof Observable) {	3!
360	translation.subscribe(translationsSubject);	×
361	} else {
362	translationsSubject.next(translation);	3✔
363	}
364	} catch (e) {
365	logger.error('parsing translation error', e);	×
366	}
367	return translationsSubject.asObservable();	3✔
368	},
369	inject: [I18nLoader, I18N_TRANSLATIONS_SUBJECT],
370	};
371	}
372
373	private static createAsyncLanguagesProvider(): Provider {
374	return {	3✔
375	provide: I18N_LANGUAGES,
376	useFactory: async (
377	loader: I18nLoader,
378	languagesSubject: BehaviorSubject<string[]>,
379	): Promise<Observable<string[]>> => {
380	try {	3✔
381	const languages = await loader.languages();	3✔
382	if (languages instanceof Observable) {	3!
383	languages.subscribe(languagesSubject);	×
384	} else {
385	languagesSubject.next(languages);	3✔
386	}
387	} catch (e) {
388	logger.error('parsing translation error', e);	×
389	}
390	return languagesSubject.asObservable();	3✔
391	},
392	inject: [I18nLoader, I18N_LANGUAGES_SUBJECT],
393	};
394	}
395
396	private static sanitizeI18nOptions<T = I18nOptions \| I18nAsyncOptions>(
397	options: T,
398	) {
399	options = { ...defaultOptions, ...options };	27✔
400	return options;	27✔
401	}
402
403	private static createResolverProviders(resolvers?: I18nOptionResolver[]) {
404	if (!resolvers \|\| resolvers.length === 0) {	21✔
405	logger.error(	12✔
406	`No resolvers provided! nestjs-i18n won't work properly, please follow the quick-start guide: https://nestjs-i18n.com/quick-start`,
407	);
408	}
409	return (resolvers \|\| [])	21!
410	.filter(shouldResolve)
411	.reduce<Provider[]>((providers, r) => {
412	if (r['use']) {	13✔
413	const { use: resolver, options, ...rest } = r as any;	6✔
414	const optionsToken = getI18nResolverOptionsToken(	6✔
415	resolver as unknown as () => void,
416	);
417	providers.push({	6✔
418	provide: resolver,
419	useClass: resolver,
420	});
421	if (options) {	6✔
422	(rest as any).useValue = options;	4✔
423	}
424	providers.push({	6✔
425	provide: optionsToken,
426	...(rest as any),
427	});
428	} else {
429	const optionsToken = getI18nResolverOptionsToken(	7✔
430	r as unknown as () => void,
431	);
432	providers.push({	7✔
433	provide: r,
434	useClass: r,
435	inject: [optionsToken],
436	} as any);
437	providers.push({	7✔
438	provide: optionsToken,
439	useFactory: () => undefined,	7✔
440	});
441	}
442
443	return providers;	13✔
444	}, []);
445	}
446	}

toonvanstrijp / nestjs-i18n / 11720602297

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous