chore(deps): update dependency prettier to v3 (#815)

* chore(deps): update dependency prettier to v3
* style: prettier
* build: remove `@types/prettier` as prettier has it's own types
* build: update prettier API usage

---------
Co-authored-by: wolfy1339 <webmaster@wolfy1339.com>

README.md

@@ -296,7 +296,7 @@ const handleWebhookEvent = (event: WebhookEvent) => {
 
 const handleIssuesOpenedEvent = (event: IssuesOpenedEvent) => {
   console.log(
-    `${event.sender.login} opened "${event.issue.title}" on ${event.repository.full_name}`
+    `${event.sender.login} opened "${event.issue.title}" on ${event.repository.full_name}`,
   );
 };
 ```

bin/diff-interface-schemas.ts

@@ -18,7 +18,7 @@ const [
     "first argument must be path to a property on an interface to compare the schema of",
     "second argument must be path to a property on an interface to compare the schema of",
   ],
-  ["full"]
+  ["full"],
 );
 
 const schemas = loadMapOfSchemas();

bin/extract-common-schema.ts

@@ -20,7 +20,7 @@ const [
     "first argument must be path to a property on an interface to extract into a common schema",
     "second argument must be name of the interface the new common schema should generate",
   ],
-  ["overwrite"]
+  ["overwrite"],
 );
 
 const RequiredSchemaProperties = [
@@ -39,26 +39,26 @@ type CommonSchema = Required<
   JSONSchema7;
 
 function assertHasRequiredProperties(
-  schema: JSONSchema7
+  schema: JSONSchema7,
 ): asserts schema is CommonSchema {
   const missingProperties = RequiredSchemaProperties.filter(
-    (property) => schema[property] === undefined
+    (property) => schema[property] === undefined,
   ).join(", ");
 
   assert.ok(
     missingProperties.length === 0,
-    `schema is missing the following required properties: ${missingProperties}`
+    `schema is missing the following required properties: ${missingProperties}`,
   );
 }
 
-const writeNewCommonSchema = (name: string, schema: JSONSchema7) => {
+const writeNewCommonSchema = async (name: string, schema: JSONSchema7) => {
   const pathToSchema = `${pathToSchemas}/common/${name}.schema.json`;
 
   assertHasRequiredProperties(schema);
 
   fs.writeFileSync(
     pathToSchema,
-    format(
+    await format(
       JSON.stringify(schema, (key, value: unknown) => {
         if (
           key === "$ref" &&
@@ -71,9 +71,9 @@ const writeNewCommonSchema = (name: string, schema: JSONSchema7) => {
 
         return value;
       }),
-      { parser: "json" }
+      { parser: "json" },
     ),
-    { flag: overwriteIfExists ? "w" : "wx" }
+    { flag: overwriteIfExists ? "w" : "wx" },
   );
 };
 

bin/format-with-prettier.ts

@@ -13,11 +13,11 @@ import {
 const [, { check: checkOnly }] = parseArgv(__filename, [], ["check"]);
 
 const formatJsonInDirectory = (pathToJsons: string) => {
-  forEachJsonFile(pathToJsons, (filePath) => {
+  forEachJsonFile(pathToJsons, async (filePath) => {
     const contentsBefore = fs.readFileSync(filePath, "utf-8");
-    const contentsAfter = format(
+    const contentsAfter = await format(
       JSON.stringify(JSON.parse(contentsBefore) as JSONSchema7),
-      { parser: "json" }
+      { parser: "json" },
     );
 
     if (contentsBefore === contentsAfter) {

bin/octokit-schema.ts

@@ -123,7 +123,7 @@ async function run() {
 
     fs.writeFileSync(
       "./payload-schemas/schema.json",
-      format(
+      await format(
         JSON.stringify(schema, (key, value: unknown) => {
           if (key === "$id") {
             return undefined;
@@ -137,8 +137,8 @@ async function run() {
 
           return value;
         }),
-        { parser: "json" }
-      )
+        { parser: "json" },
+      ),
     );
   } catch (err) {
     console.error(err);

bin/octokit-types.ts

@@ -12,12 +12,12 @@ parseArgv(__filename, []);
 const getEventName = (ref: string): string => {
   assert.ok(
     ref.startsWith("#/definitions/"),
-    `${ref} does not point to definitions`
+    `${ref} does not point to definitions`,
   );
 
   assert.ok(
     ref.endsWith("event"),
-    `${ref} does not point to an event definition`
+    `${ref} does not point to an event definition`,
   );
 
   const [, eventName] = /^#\/definitions\/(.+)[$_]event$/u.exec(ref) ?? [];
@@ -44,7 +44,7 @@ const buildEventPayloadMap = (schema: Schema): string => {
 
 const getSchema = async () =>
   JSON.parse(
-    await fs.readFile("./payload-schemas/schema.json", "utf-8")
+    await fs.readFile("./payload-schemas/schema.json", "utf-8"),
   ) as Schema;
 
 declare module "json-schema" {
@@ -71,7 +71,7 @@ const compileSchema = async (): Promise<string> => {
       }
 
       return value;
-    }
+    },
   ) as JSONSchema4;
 
   return compile(schema, "Schema", { format: false });
@@ -92,7 +92,7 @@ const run = async () => {
 
   await fs.writeFile(
     "./payload-types/schema.d.ts",
-    format(ts, { parser: "typescript" })
+    await format(ts, { parser: "typescript" }),
   );
 };
 

bin/optimize-schemas.ts

@@ -29,7 +29,7 @@ const JSONSchema7TypeNameOrder = [
 ] as const;
 
 const standardizeTypeProperty = (
-  types: JSONSchema7TypeName[]
+  types: JSONSchema7TypeName[],
 ): JSONSchema7TypeName | JSONSchema7TypeName[] => {
   if (types.length === 1) {
     return types[0];
@@ -39,7 +39,7 @@ const standardizeTypeProperty = (
 };
 
 const isNullType = (
-  object: JSONSchema7Definition
+  object: JSONSchema7Definition,
 ): object is { type: "null" | ["null"] } & JSONSchema7 => {
   if (typeof object === "boolean") {
     return false;
@@ -68,12 +68,12 @@ const addNullToObject = (object: JSONSchema7) => {
   }
 };
 
-forEachJsonFile(pathToSchemas, (pathToSchema) => {
+forEachJsonFile(pathToSchemas, async (pathToSchema) => {
   const contents = JSON.parse(fs.readFileSync(pathToSchema, "utf-8"));
 
   fs.writeFileSync(
     pathToSchema,
-    format(
+    await format(
       JSON.stringify(contents, (key, value: unknown | JSONSchema7) => {
         if (!isJsonSchemaObject(value)) {
           return value;
@@ -112,12 +112,12 @@ forEachJsonFile(pathToSchemas, (pathToSchema) => {
           // { "type": "null" } & { ... } can be combined as "type" supports an array
           if (value.oneOf.some(isNullType)) {
             const [notNullType] = value.oneOf.filter(
-              (object) => !isNullType(object)
+              (object) => !isNullType(object),
             );
 
             assert.ok(
               typeof notNullType !== "boolean",
-              "unexpected boolean in oneOf"
+              "unexpected boolean in oneOf",
             );
 
             if (!notNullType.$ref && !notNullType.allOf) {
@@ -135,7 +135,7 @@ forEachJsonFile(pathToSchemas, (pathToSchema) => {
 
         return value;
       }),
-      { parser: "json" }
-    )
+      { parser: "json" },
+    ),
   );
 });

bin/ref-common-schemas.ts

@@ -19,22 +19,22 @@ const commonSchemas = fs
   .map<[name: string, schema: JSONSchema7]>((commonSchema) => [
     commonSchema,
     normalizeSchema(
-      require(`../${pathToSchemas}/common/${commonSchema}`) as JSONSchema7
+      require(`../${pathToSchemas}/common/${commonSchema}`) as JSONSchema7,
     ),
   ]);
 
 const findCommonSchema = (object: JSONSchema7) => {
   const normalisedSchema = normalizeSchema(object);
 
   const [schema] = commonSchemas.find(([, commonSchema]) =>
-    deepEqual(commonSchema, normalisedSchema)
+    deepEqual(commonSchema, normalisedSchema),
   ) ?? [null];
 
   return schema;
 };
 
 const splitIntoObjectAndNull = (
-  object: Readonly<JSONSchema7>
+  object: Readonly<JSONSchema7>,
 ): [JSONSchema7, { type: "null" } | null] => {
   // if the object cannot be null, just return the object
   if (!ensureArray(object.type).includes("null")) {
@@ -56,7 +56,7 @@ const splitIntoObjectAndNull = (
 
 let count = 0;
 
-forEachJsonFile(pathToSchemas, (filePath) => {
+forEachJsonFile(pathToSchemas, async (filePath) => {
   if (filePath.includes("/common/")) {
     return;
   }
@@ -65,7 +65,7 @@ forEachJsonFile(pathToSchemas, (filePath) => {
 
   fs.writeFileSync(
     filePath,
-    format(
+    await format(
       JSON.stringify(schema, (key, value) => {
         if (typeof value === "object" && value !== null) {
           const [object, nullType] = splitIntoObjectAndNull(value);
@@ -87,11 +87,11 @@ forEachJsonFile(pathToSchemas, (filePath) => {
 
         return value;
       }),
-      { parser: "json" }
-    )
+      { parser: "json" },
+    ),
   );
 });
 
 console.log(
-  `replaced ${count} ${count === 1 ? "property" : "properties"} with $ref`
+  `replaced ${count} ${count === 1 ? "property" : "properties"} with $ref`,
 );

bin/utils/argv.ts

@@ -13,13 +13,13 @@ type Join<T extends unknown[], D extends string> = T extends []
 
 type CapitalizeIf<
   Condition extends boolean,
-  T extends string
+  T extends string,
 > = Condition extends true ? Capitalize<T> : T;
 
 type SplitCamel<
   S extends string,
   D extends string,
-  IsTail extends boolean = false
+  IsTail extends boolean = false,
 > = string extends S
   ? string[]
   : S extends ""
@@ -49,7 +49,7 @@ const getArgsAndFlags = (argv: string[]): [args: string[], flags: string[]] => {
 
 function assertHasRequiredArgs<T extends string[]>(
   foundArgs: string[],
-  requiredArgs: T
+  requiredArgs: T,
 ): asserts foundArgs is T {
   requiredArgs.forEach((missingMessage, index) => {
     assert.ok(foundArgs[index], missingMessage);
@@ -81,12 +81,12 @@ const getHelpText = (pathToScript: string, full = false): string => {
 
 const isSupportedFlag = <TFlag extends string>(
   flag: string,
-  supportedFlags: TFlag[]
+  supportedFlags: TFlag[],
 ): flag is TFlag => supportedFlags.includes(flag as TFlag);
 
 const processFlags = <TFlag extends string>(
   flags: string[],
-  supportedFlags: TFlag[] = []
+  supportedFlags: TFlag[] = [],
 ): CamelCasedFlags<TFlag> => {
   const finalFlags: CamelCasedFlags<TFlag> = {};
 
@@ -106,7 +106,7 @@ const processFlags = <TFlag extends string>(
 export const parseArgv = <TRequiredArgs extends string[], TFlag extends string>(
   pathToScript: string,
   argsMissingMessages: TRequiredArgs,
-  supportedFlags: TFlag[] = []
+  supportedFlags: TFlag[] = [],
 ): [args: TRequiredArgs, flags: CamelCasedFlags<TFlag>] => {
   const [foundArgs, flags] = getArgsAndFlags(process.argv.slice(2));
 

bin/utils/forEachJsonFile.ts

@@ -2,7 +2,7 @@ import fs from "fs";
 
 export const forEachJsonFile = (
   directory: string,
-  callback: (pathToFile: string) => void
+  callback: (pathToFile: string) => void,
 ) => {
   fs.readdirSync(directory, { withFileTypes: true }).forEach((entity) => {
     const pathToEntity = `${directory}/${entity.name}`;

bin/utils/getSchemaFromPath.ts

@@ -6,7 +6,7 @@ const extractFromSchema = (schema: JSONSchema7, name: string): JSONSchema7 => {
   if (ensureArray(schema.type).includes("object")) {
     assert.ok(
       schema.properties,
-      "cannot extract from an object-type schema that lacks properties"
+      "cannot extract from an object-type schema that lacks properties",
     );
 
     const value = schema.properties[name];
@@ -25,17 +25,17 @@ const extractFromSchema = (schema: JSONSchema7, name: string): JSONSchema7 => {
   }
 
   throw new Error(
-    `schemas can only be extracted from objects or arrays (got ${schema.type})`
+    `schemas can only be extracted from objects or arrays (got ${schema.type})`,
   );
 };
 
 export const getSchemaFromPath = (
   interfacePropertyPath: string,
-  schemas: Record<string, JSONSchema7>
+  schemas: Record<string, JSONSchema7>,
 ): JSONSchema7 =>
   interfacePropertyPath
     .split(".")
     .reduce<JSONSchema7>(
       (schema, segment) => extractFromSchema(schema, segment),
-      { type: "object", properties: schemas }
+      { type: "object", properties: schemas },
     );

bin/utils/loadMapOfSchemas.ts

@@ -9,7 +9,7 @@ export const loadMapOfSchemas = (): Record<string, JSONSchema7> => {
 
   forEachJsonFile(pathToSchemas, (pathToSchema) => {
     const schema = JSON.parse(
-      fs.readFileSync(pathToSchema, "utf-8")
+      fs.readFileSync(pathToSchema, "utf-8"),
     ) as JSONSchema7;
 
     entries.push([guessAtInterfaceName(schema), schema]);

bin/validate-payload-examples.ts

@@ -9,7 +9,7 @@ import { forEachJsonFile, parseArgv, pathToPayloads } from "./utils";
 const [, { continueOnError = false }] = parseArgv(
   __filename,
   [],
-  ["continue-on-error"]
+  ["continue-on-error"],
 );
 
 const printAjvErrors = () => {
@@ -18,7 +18,7 @@ const printAjvErrors = () => {
   ajv.errors?.forEach((error) => {
     const similarError = finalErrors.find(
       (er) =>
-        er.keyword === error.keyword && er.instancePath === error.instancePath
+        er.keyword === error.keyword && er.instancePath === error.instancePath,
     ) as DefinedError | undefined;
 
     if (similarError?.keyword === "enum") {
@@ -37,7 +37,7 @@ forEachJsonFile(pathToPayloads, (filePath) => {
   if (filePath.includes("/index.json")) return;
   const file = require(`../${filePath}`) as unknown;
   const { dir: event, base: filename } = path.parse(
-    path.relative(pathToPayloads, filePath)
+    path.relative(pathToPayloads, filePath),
   );
 
   try {

bin/validate-schema.ts

@@ -14,7 +14,7 @@ addFormats(ajv);
 ajv.addKeyword("tsAdditionalProperties");
 
 const schema = JSON.parse(
-  readFileSync(resolve(__dirname, "../payload-schemas/schema.json"), "utf-8")
+  readFileSync(resolve(__dirname, "../payload-schemas/schema.json"), "utf-8"),
 );
 
 // if this is invalid, an error will be thrown