2224909366

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/jungvonmatt/contentful-ssg/commit/<a class=hub.com/jungvonmatt/contentful-ssg/commit/5206f93e2f1dc26f1b63d523bb1ea43507f351f3">5206f93e2<a href="https://github.com/jungvonmatt/contentful-ssg/commit/5206f93e2f1dc26f1b63d523bb1ea43507f351f3">">Merge </a><a class="double-link" href="https://github.com/jungvonmatt/contentful-ssg/commit/<a class="double-link" href="https://github.com/jungvonmatt/contentful-ssg/commit/d3398cda4f2f03ce0ff3bc2039a3859fac62131f">d3398cda4</a>">d3398cda4</a><a href="https://github.com/jungvonmatt/contentful-ssg/commit/5206f93e2f1dc26f1b63d523bb1ea43507f351f3"> into 52dbc5a7b">52dbc5a7b</a>

Pull Request Pull Request #39: feat(utils): adds waitFor util

Run Details

252 of 336 branches covered (75.0%)

Branch coverage included in aggregate %.

62 of 62 new or added lines in 4 files covered. (100.0%)

701 of 748 relevant lines covered (93.72%)

59.57 hits per line

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

67.47

/packages/contentful-ssg/src/index.ts

import type {
  Config,
  ObservableContext,
  RuntimeContext,
  Task,
  TransformContext,
  TransformHelper,
} from './types.js';
import Listr from 'listr';
import { BehaviorSubject } from 'rxjs';
import chalk from 'chalk';
import { getContentTypeId, getContentId } from './lib/contentful.js';
import { setup } from './tasks/setup.js';
import { fetch } from './tasks/fetch.js';
import { localize } from './tasks/localize.js';
import { transform } from './tasks/transform.js';
import { write } from './tasks/write.js';
import { collectParentValues, collectValues, waitFor } from './lib/utils.js';
import { ValidationError } from './lib/error.js';

/**
 * This is a very simple listr renderer which does not swallow log output from
 * the configured helper functions.
 */
class CustomListrRenderer {
  readonly _tasks: Task[];
  constructor(tasks: Task[]) {
    this._tasks = tasks;
  }

  // eslint-disable-next-line @typescript-eslint/naming-convention
  static get nonTTY() {
    return false;
  }

  // eslint-disable-next-line @typescript-eslint/member-ordering
  static subscribeTasks(tasks: Task[], indent = '') {
    for (const task of tasks) {
      task.subscribe((event) => {
        if (event.type === 'STATE' && task.isPending()) {
          console.log(`${indent}  ${chalk.yellow('\u279E')} ${task.title}`);
        }

        if (event.type === 'SUBTASKS' && task.subtasks.length > 0) {
          CustomListrRenderer.subscribeTasks(task.subtasks as unknown as Task[], indent + '  ');
        }
      });
    }
  }

  render() {
    CustomListrRenderer.subscribeTasks(this._tasks);
  }

  end(err) {
    if (!err) {
      console.log(`  ${chalk.green('✔')} all tasks done!`);
    }
  }
}

/**
 * Dump contentful objects to files
 * @param {Object} config
 */
export const run = async (config: Config): Promise<void> => {
  const tasks = new Listr<RuntimeContext>(
    [
      {
        title: 'Setup',
        task: async (ctx) => setup(ctx, config),
      },
      {
        title: 'Pulling data from contentful',
        task: async (ctx) => fetch(ctx, config),
      },
      {
        title: 'Localize data',
        task: async (ctx) => localize(ctx),
      },
      {
        title: 'Before Hook',
        skip: (ctx) => !ctx.hooks.has('before'),
        task: async (ctx) => ctx.hooks.before(),
      },
      {
        title: 'Writing files',
        task: async (ctx) => {
          const { locales = [] } = ctx.data;

          const tasks = locales.map((locale) => ({
            title: `${locale.code}`,
            task: async () => {
              const subject = new BehaviorSubject<ObservableContext>(null);
              const observable = subject.asObservable();
              const data = ctx.localized.get(locale.code);
              const { entries = [] } = data || {};

              const promises = entries.map(async (entry) => {
                const id = getContentId(entry);
                const contentTypeId = getContentTypeId(entry);

                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
                const utils = {
                  collectValues: collectValues({ ...data, entry }),
                  collectParentValues: collectParentValues({ ...data, entry }),
                  waitFor: waitFor({ ...data, entry, observable }),
                } as TransformHelper;

                const transformContext: TransformContext = {
                  ...data,
                  id,
                  contentTypeId,
                  entry,
                  locale,
                  utils,
                  observable,
                };

                try {
                  const content = await transform(transformContext, ctx, config);
                  subject.next({ ...transformContext, content });

                  if (typeof content === 'undefined') {
                    return;
                  }

                  await write({ ...transformContext, content }, ctx, config);
                  ctx.stats.addSuccess(transformContext);
                } catch (error: unknown) {
                  if (error instanceof Error) {
                    subject.next({ ...transformContext, error });
                  } else {
                    // eslint-disable-next-line @typescript-eslint/no-base-to-string, @typescript-eslint/restrict-template-expressions
                    subject.next({ ...transformContext, error: new Error(`${error}`) });
                  }

                  if (error instanceof ValidationError) {
                    ctx.stats.addSkipped(transformContext, error);
                  } else {
                    ctx.stats.addError(transformContext, error);
                  }
                }
              });

              return Promise.all(promises);
            },
          }));
          return new Listr(tasks, { concurrent: true });
        },
      },
      {
        title: 'After Hook',
        skip: (ctx) => !ctx.hooks.has('after'),
        task: async (ctx) => ctx.hooks.after(),
      },
      {
        title: 'Cleanup',
        task: async (ctx) => ctx.fileManager.cleanup(),
      },
    ],
    { renderer: CustomListrRenderer }
  );

  const ctx = await tasks.run();
  await ctx.stats.print();
  console.log('\n---------------------------------------------');

  if (ctx.stats.errors?.length && !config.ignoreErrors) {
    process.exit(1);
  }
};

1	import type {
2	Config,
3	ObservableContext,
4	RuntimeContext,
5	Task,
6	TransformContext,
7	TransformHelper,
8	} from './types.js';
9	import Listr from 'listr';	1✔
10	import { BehaviorSubject } from 'rxjs';	1✔
11	import chalk from 'chalk';	1✔
12	import { getContentTypeId, getContentId } from './lib/contentful.js';	1✔
13	import { setup } from './tasks/setup.js';	1✔
14	import { fetch } from './tasks/fetch.js';	1✔
15	import { localize } from './tasks/localize.js';	1✔
16	import { transform } from './tasks/transform.js';	1✔
17	import { write } from './tasks/write.js';	1✔
18	import { collectParentValues, collectValues, waitFor } from './lib/utils.js';	1✔
19	import { ValidationError } from './lib/error.js';	1✔
20
21	/**
22	* This is a very simple listr renderer which does not swallow log output from
23	* the configured helper functions.
24	*/
25	class CustomListrRenderer {
26	readonly _tasks: Task[];
27	constructor(tasks: Task[]) {
28	this._tasks = tasks;	×
29	}
30
31	// eslint-disable-next-line @typescript-eslint/naming-convention
32	static get nonTTY() {
33	return false;	5✔
34	}
35
36	// eslint-disable-next-line @typescript-eslint/member-ordering
37	static subscribeTasks(tasks: Task[], indent = '') {	×
38	for (const task of tasks) {	×
39	task.subscribe((event) => {	×
40	if (event.type === 'STATE' && task.isPending()) {	×
41	console.log(`${indent} ${chalk.yellow('\u279E')} ${task.title}`);	×
42	}
43
44	if (event.type === 'SUBTASKS' && task.subtasks.length > 0) {	×
45	CustomListrRenderer.subscribeTasks(task.subtasks as unknown as Task[], indent + ' ');	×
46	}
47	});
48	}
49	}
50
51	render() {
52	CustomListrRenderer.subscribeTasks(this._tasks);	×
53	}
54
55	end(err) {
56	if (!err) {	×
57	console.log(` ${chalk.green('✔')} all tasks done!`);	×
58	}
59	}
60	}
61
62	/**
63	* Dump contentful objects to files
64	* @param {Object} config
65	*/
66	export const run = async (config: Config): Promise<void> => {	1✔
67	const tasks = new Listr<RuntimeContext>(	5✔
68	[
69	{
70	title: 'Setup',
71	task: async (ctx) => setup(ctx, config),	5✔
72	},
73	{
74	title: 'Pulling data from contentful',
75	task: async (ctx) => fetch(ctx, config),	5✔
76	},
77	{
78	title: 'Localize data',
79	task: async (ctx) => localize(ctx),	5✔
80	},
81	{
82	title: 'Before Hook',
83	skip: (ctx) => !ctx.hooks.has('before'),	5✔
84	task: async (ctx) => ctx.hooks.before(),	2✔
85	},
86	{
87	title: 'Writing files',
88	task: async (ctx) => {
89	const { locales = [] } = ctx.data;	4!
90
91	const tasks = locales.map((locale) => ({	12✔
92	title: `${locale.code}`,
93	task: async () => {
94	const subject = new BehaviorSubject<ObservableContext>(null);	12✔
95	const observable = subject.asObservable();	12✔
96	const data = ctx.localized.get(locale.code);	12✔
97	const { entries = [] } = data \|\| {};	12!
98
99	const promises = entries.map(async (entry) => {	12✔
100	const id = getContentId(entry);	48✔
101	const contentTypeId = getContentTypeId(entry);	48✔
102
103	// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
104	const utils = {	48✔
105	collectValues: collectValues({ ...data, entry }),
106	collectParentValues: collectParentValues({ ...data, entry }),
107	waitFor: waitFor({ ...data, entry, observable }),
108	} as TransformHelper;
109
110	const transformContext: TransformContext = {	48✔
111	...data,
112	id,
113	contentTypeId,
114	entry,
115	locale,
116	utils,
117	observable,
118	};
119
120	try {	48✔
121	const content = await transform(transformContext, ctx, config);	48✔
122	subject.next({ ...transformContext, content });	24✔
123
124	if (typeof content === 'undefined') {	24!
125	return;	×
126	}
127
128	await write({ ...transformContext, content }, ctx, config);	24✔
129	ctx.stats.addSuccess(transformContext);	24✔
130	} catch (error: unknown) {
131	if (error instanceof Error) {	24!
132	subject.next({ ...transformContext, error });	24✔
133	} else {
134	// eslint-disable-next-line @typescript-eslint/no-base-to-string, @typescript-eslint/restrict-template-expressions
135	subject.next({ ...transformContext, error: new Error(`${error}`) });	×
136	}
137
138	if (error instanceof ValidationError) {	24!
139	ctx.stats.addSkipped(transformContext, error);	×
140	} else {
141	ctx.stats.addError(transformContext, error);	24✔
142	}
143	}
144	});
145
146	return Promise.all(promises);	12✔
147	},
148	}));
149	return new Listr(tasks, { concurrent: true });	4✔
150	},
151	},
152	{
153	title: 'After Hook',
154	skip: (ctx) => !ctx.hooks.has('after'),	4✔
155	task: async (ctx) => ctx.hooks.after(),	2✔
156	},
157	{
158	title: 'Cleanup',
159	task: async (ctx) => ctx.fileManager.cleanup(),	3✔
160	},
161	],
162	{ renderer: CustomListrRenderer }
163	);
164
165	const ctx = await tasks.run();	5✔
166	await ctx.stats.print();	3✔
167	console.log('\n---------------------------------------------');	3✔
168
169	if (ctx.stats.errors?.length && !config.ignoreErrors) {	3✔
170	process.exit(1);	1✔
171	}
172	};

jungvonmatt / contentful-ssg / 2224909366

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