3296189389

Build Type

push

github

Committed by GitHub

Commit Message

fix: typo in CronDetector searchpath (#1058)

Run Details

596 of 791 branches covered (75.35%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

1141 of 1328 relevant lines covered (85.92%)

22.43 hits per line

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

75.57

/src/cli/cron-detector.ts

import { cronExpression, timezone } from "../client/index";
import { cron } from "../client/index";
import fs from "fs";
import * as chokidar from "chokidar";
import { parseChokidarRulesFromGitignore } from "./parse-gitignore";
import * as babel from "@babel/parser";
import traverse from "@babel/traverse";
import path from "path";
import * as config from "../client/config";

export interface DetectedCronJob {
  route: string;
  schedule: string;
  timezone: string;
  framework: string;
  isValid: boolean;
}

export function detectQuirrelCronJob(file: string): DetectedCronJob | null {
  const quirrelImport = /["']quirrel\/(.*)["']/.exec(file);
  if (!quirrelImport) {
    return null;
  }

  const clientFramework = quirrelImport[1];

  let jobName: string | undefined;
  let cronSchedule: string | undefined;
  let cronTimezone: string | undefined;

  try {
    const ast = babel.parse(file, {
      sourceType: "unambiguous",
      plugins: ["typescript"],
    });
    traverse(ast, {
      CallExpression(path) {
        const { callee } = path.node;
        if (callee.type !== "Identifier" || callee.name !== "CronJob") {
          return;
        }

        if (path.node.arguments.length < 3) {
          return;
        }

        const [jobNameNode, cronScheduleNode] = path.node.arguments;
        if (jobNameNode.type !== "StringLiteral") {
          return;
        }

        jobName = jobNameNode.value;

        if (cronScheduleNode.type === "StringLiteral") {
          cronSchedule = cronScheduleNode.value;
        } else if (cronScheduleNode.type === "ArrayExpression") {
          if (cronScheduleNode.elements.length > 2) {
            return;
          }

          const [scheduleNode, timezoneNode] = cronScheduleNode.elements;
          if (scheduleNode?.type !== "StringLiteral") {
            return;
          }

          cronSchedule = scheduleNode.value;

          if (timezoneNode?.type !== "StringLiteral") {
            return;
          }

          cronTimezone = timezoneNode.value;
        }

        path.stop();
      },
    });

    if (!cronSchedule || !jobName) {
      return null;
    }

    return {
      route: config.withoutLeadingSlash(jobName),
      schedule: cronSchedule,
      timezone: cronTimezone ?? "Etc/UTC",
      framework: clientFramework,
      isValid:
        cron.safeParse(cronSchedule).success &&
        timezone.optional().safeParse(cronTimezone).success,
    };
  } catch (error) {
    return null;
  }
}

export class CronDetector {
  private watcher: chokidar.FSWatcher;
  private ready = false;

  constructor(
    private readonly cwd: string,
    private readonly onChange?: (jobs: DetectedCronJob[]) => void
  ) {
    const rules = parseChokidarRulesFromGitignore(cwd);
    this.watcher = chokidar.watch(["**/*.[jt]s", "**/*.[jt]sx"], {
      ignored: ["node_modules", "**/node_modules", ...rules.ignoredPaths],
      cwd,
    });

    this.watcher.on("add", this.on("added"));
    this.watcher.on("change", this.on("changed"));
    this.watcher.on("unlink", this.on("deleted"));
    this.watcher.on("ready", () => {
      this.ready = true;
    });
  }

  public async close() {
    await this.watcher.close();
  }

  public async awaitReady() {
    if (this.ready) {
      return;
    }

    await new Promise((resolve) => {
      this.watcher.on("ready", resolve);
    });
  }

  private pathToCronJob: Record<string, DetectedCronJob> = {};

  public getDetectedJobs(): DetectedCronJob[] {
    return Object.values(this.pathToCronJob);
  }

  private async onNewJob(job: DetectedCronJob, filePath: string) {
    await this.onJobChanged(job, filePath);
  }

  private emitChange() {
    this.onChange?.(this.getDetectedJobs());
  }

  private async onJobRemoved(job: DetectedCronJob, filePath: string) {
    delete this.pathToCronJob[filePath];

    this.emitChange();
  }

  private async onJobChanged(job: DetectedCronJob, filePath: string) {
    this.pathToCronJob[filePath] = job;

    this.emitChange();
  }

  private on(fileChangeType: "changed" | "deleted" | "added") {
    return async (filePath: string) => {
      const previousJob = this.pathToCronJob[filePath];

      if (fileChangeType === "deleted") {
        if (previousJob) {
          await this.onJobRemoved(previousJob, filePath);
        }

        return;
      }

      const contents = fs.readFileSync(path.join(this.cwd, filePath), "utf-8");
      const newJob = detectQuirrelCronJob(contents);

      if (!newJob) {
        if (previousJob) {
          await this.onJobRemoved(previousJob, filePath);
        }

        return;
      }

      if (!newJob.isValid) {
        console.error(
          `🚨Encountered invalid cron expression: ${newJob.schedule}`
        );
        return;
      }

      if (!previousJob && newJob) {
        return await this.onNewJob(newJob, filePath);
      }

      if (previousJob && newJob) {
        return await this.onJobChanged(newJob, filePath);
      }
    };
  }
}

1	import { cronExpression, timezone } from "../client/index";
2	import { cron } from "../client/index";
3	import fs from "fs";
4	import * as chokidar from "chokidar";
5	import { parseChokidarRulesFromGitignore } from "./parse-gitignore";
6	import * as babel from "@babel/parser";
7	import traverse from "@babel/traverse";
8	import path from "path";
9	import * as config from "../client/config";
10
11	export interface DetectedCronJob {
12	route: string;
13	schedule: string;
14	timezone: string;
15	framework: string;
16	isValid: boolean;
17	}
18
19	export function detectQuirrelCronJob(file: string): DetectedCronJob \| null {
20	const quirrelImport = /["']quirrel\/(.*)["']/.exec(file);
21	if (!quirrelImport) {	22✔
22	return null;
23	}
24
25	const clientFramework = quirrelImport[1];
26
27	let jobName: string \| undefined;
28	let cronSchedule: string \| undefined;
29	let cronTimezone: string \| undefined;
30
31	try {
32	const ast = babel.parse(file, {
33	sourceType: "unambiguous",
34	plugins: ["typescript"],
35	});
36	traverse(ast, {
37	CallExpression(path) {
38	const { callee } = path.node;
39	if (callee.type !== "Identifier" \|\| callee.name !== "CronJob") {	55✔
40	return;
41	}
42
43	if (path.node.arguments.length < 3) {	×
44	return;
45	}
46
47	const [jobNameNode, cronScheduleNode] = path.node.arguments;
48	if (jobNameNode.type !== "StringLiteral") {	×
49	return;
50	}
51
52	jobName = jobNameNode.value;
53
54	if (cronScheduleNode.type === "StringLiteral") {	15✔
55	cronSchedule = cronScheduleNode.value;
56	} else if (cronScheduleNode.type === "ArrayExpression") {	6✔
57	if (cronScheduleNode.elements.length > 2) {	×
58	return;
59	}
60
61	const [scheduleNode, timezoneNode] = cronScheduleNode.elements;
62	if (scheduleNode?.type !== "StringLiteral") {	18!
63	return;
64	}
65
66	cronSchedule = scheduleNode.value;
67
68	if (timezoneNode?.type !== "StringLiteral") {	18!
69	return;
70	}
71
72	cronTimezone = timezoneNode.value;
73	}
74
75	path.stop();
76	},
77	});
78
79	if (!cronSchedule \|\| !jobName) {	40✔
80	return null;
81	}
82
83	return {
84	route: config.withoutLeadingSlash(jobName),
85	schedule: cronSchedule,
86	timezone: cronTimezone ?? "Etc/UTC",	45✔
87	framework: clientFramework,
88	isValid:
89	cron.safeParse(cronSchedule).success &&	30✔
90	timezone.optional().safeParse(cronTimezone).success,
91	};
92	} catch (error) {
93	return null;
94	}
95	}
96
97	export class CronDetector {
98	private watcher: chokidar.FSWatcher;
99	private ready = false;
100
101	constructor(
102	private readonly cwd: string,
103	private readonly onChange?: (jobs: DetectedCronJob[]) => void
104	) {
105	const rules = parseChokidarRulesFromGitignore(cwd);
106	this.watcher = chokidar.watch(["*/.[jt]s", "*/.[jt]sx"], {
107	ignored: ["node_modules", "**/node_modules", ...rules.ignoredPaths],
108	cwd,
109	});
110
111	this.watcher.on("add", this.on("added"));
112	this.watcher.on("change", this.on("changed"));
113	this.watcher.on("unlink", this.on("deleted"));
114	this.watcher.on("ready", () => {
115	this.ready = true;
116	});
117	}
118
119	public async close() {
120	await this.watcher.close();
121	}
122
123	public async awaitReady() {
124	if (this.ready) {	×
125	return;
126	}
127
128	await new Promise((resolve) => {
129	this.watcher.on("ready", resolve);
130	});
131	}
132
133	private pathToCronJob: Record<string, DetectedCronJob> = {};
134
135	public getDetectedJobs(): DetectedCronJob[] {
136	return Object.values(this.pathToCronJob);
137	}
138
139	private async onNewJob(job: DetectedCronJob, filePath: string) {
140	await this.onJobChanged(job, filePath);
141	}
142
143	private emitChange() {
144	this.onChange?.(this.getDetectedJobs());	24!
145	}
146
147	private async onJobRemoved(job: DetectedCronJob, filePath: string) {
148	delete this.pathToCronJob[filePath];
149
150	this.emitChange();
151	}
152
153	private async onJobChanged(job: DetectedCronJob, filePath: string) {
154	this.pathToCronJob[filePath] = job;
155
156	this.emitChange();
157	}
158
159	private on(fileChangeType: "changed" \| "deleted" \| "added") {
160	return async (filePath: string) => {
161	const previousJob = this.pathToCronJob[filePath];
162
163	if (fileChangeType === "deleted") {	×
164	if (previousJob) {	×
165	await this.onJobRemoved(previousJob, filePath);
166	}
167
168	return;
169	}
170
171	const contents = fs.readFileSync(path.join(this.cwd, filePath), "utf-8");
172	const newJob = detectQuirrelCronJob(contents);
173
174	if (!newJob) {	27✔
175	if (previousJob) {	×
176	await this.onJobRemoved(previousJob, filePath);
177	}
178
179	return;
180	}
181
182	if (!newJob.isValid) {	×
NEW 183	console.error(
184	`🚨Encountered invalid cron expression: ${newJob.schedule}`
185	);
UNCOV 186	return;
187	}
188
189	if (!previousJob && newJob) {	24✔
190	return await this.onNewJob(newJob, filePath);
191	}
192
193	if (previousJob && newJob) {	×
194	return await this.onJobChanged(newJob, filePath);
195	}
196	};
197	}
198	}

quirrel-dev / quirrel / 3296189389

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