Merge branch 'master' into feat/namespace

src/contentful-typescript-codegen.ts

@@ -19,6 +19,7 @@ const cli = meow(
                        and present, and does not provide types for Sys,
                        Assets, or Rich Text. This is useful for ensuring raw
                        Contentful responses will be compatible with your code.
+    --localization -l  Output fields with localized values
 
   Examples
     $ contentful-typescript-codegen -o src/@types/generated/contentful.d.ts
@@ -49,6 +50,11 @@ const cli = meow(
         alias: "n",
         required: false,
       },
+      localization: {
+        type: "boolean",
+        alias: "l",
+        required: false,
+      },
     },
   },
 )
@@ -65,7 +71,10 @@ async function runCodegen(outputFile: string) {
   if (cli.flags.fieldsOnly) {
     output = await renderFieldsOnly(contentTypes.items, { namespace: cli.flags.namespace })
   } else {
-    output = await render(contentTypes.items, locales.items, { namespace: cli.flags.namespace })
+    output = await render(contentTypes.items, locales.items, {
+      localization: cli.flags.localization,
+      namespace: cli.flags.namespace,
+    })
   }
 
   outputFileSync(outputPath, output)

src/renderers/contentful/renderContentType.ts

@@ -13,9 +13,9 @@ import renderObject from "./fields/renderObject"
 import renderRichText from "./fields/renderRichText"
 import renderSymbol from "./fields/renderSymbol"
 
-export default function renderContentType(contentType: ContentType): string {
+export default function renderContentType(contentType: ContentType, localization: boolean): string {
   const name = renderContentTypeId(contentType.sys.id)
-  const fields = renderContentTypeFields(contentType.fields)
+  const fields = renderContentTypeFields(contentType.fields, localization)
   const sys = renderSys(contentType.sys)
 
   return `
@@ -34,7 +34,7 @@ function descriptionComment(description: string | undefined) {
   return ""
 }
 
-function renderContentTypeFields(fields: Field[]): string {
+function renderContentTypeFields(fields: Field[], localization: boolean): string {
   return fields
     .filter(field => !field.omitted)
     .map<string>(field => {
@@ -52,7 +52,7 @@ function renderContentTypeFields(fields: Field[]): string {
         Text: renderSymbol,
       }
 
-      return renderField(field, functionMap[field.type](field))
+      return renderField(field, functionMap[field.type](field), localization)
     })
     .join("\n\n")
 }

src/renderers/contentful/renderContentfulImports.ts

@@ -1,4 +1,13 @@
-export default function renderContentfulImports(): string {
+export default function renderContentfulImports(localization: boolean = false): string {
+  if (localization) {
+    return `
+    // THIS FILE IS AUTOMATICALLY GENERATED. DO NOT MODIFY IT.
+
+    import { Entry } from 'contentful'
+    import { Document } from '@contentful/rich-text-types'
+  `
+  }
+
   return `
     // THIS FILE IS AUTOMATICALLY GENERATED. DO NOT MODIFY IT.
 

src/renderers/contentful/renderField.ts

@@ -1,6 +1,10 @@
 import { Field } from "contentful"
 import renderInterfaceProperty from "../typescript/renderInterfaceProperty"
 
-export default function renderField(field: Field, type: string): string {
-  return renderInterfaceProperty(field.id, type, field.required, field.name)
+export default function renderField(
+  field: Field,
+  type: string,
+  localization: boolean = false,
+): string {
+  return renderInterfaceProperty(field.id, type, field.required, localization, field.name)
 }

src/renderers/contentful/renderLocalizedTypes.ts

@@ -0,0 +1,30 @@
+/** renders helper types for --localization flag */
+export default function renderLocalizedTypes(localization: boolean) {
+  if (!localization) return null
+
+  return `
+    export type LocalizedField<T> = Partial<Record<LOCALE_CODE, T>>
+  
+    // We have to use our own localized version of Asset because of a bug in contentful https://github.com/contentful/contentful.js/issues/208
+    export interface Asset {
+      sys: Sys
+      fields: {
+        title: LocalizedField<string>
+        description: LocalizedField<string>
+        file: LocalizedField<{
+          url: string
+          details: {
+            size: number
+            image?: {
+              width: number
+              height: number
+            }
+          }
+          fileName: string
+          contentType: string
+        }>
+      }
+      toPlainObject(): object
+    }
+  `
+}

src/renderers/render.ts

@@ -8,24 +8,28 @@ import renderUnion from "./typescript/renderUnion"
 import renderAllLocales from "./contentful/renderAllLocales"
 import renderDefaultLocale from "./contentful/renderDefaultLocale"
 import renderNamespace from "./contentful/renderNamespace"
+import renderLocalizedTypes from "./contentful/renderLocalizedTypes"
 
 interface Options {
+  localization?: boolean
   namespace?: string
 }
 
 export default async function render(
   contentTypes: ContentType[],
   locales: Locale[],
-  { namespace }: Options = {},
+  { namespace, localization = false }: Options = {},
 ) {
   const sortedContentTypes = contentTypes.sort((a, b) => a.sys.id.localeCompare(b.sys.id))
   const sortedLocales = locales.sort((a, b) => a.code.localeCompare(b.code))
 
   const typingsSource = [
-    renderAllContentTypes(sortedContentTypes),
+    renderContentfulImports(localization),
+    renderAllContentTypes(sortedContentTypes, localization),
     renderAllContentTypeIds(sortedContentTypes),
     renderAllLocales(sortedLocales),
     renderDefaultLocale(sortedLocales),
+    renderLocalizedTypes(localization),
   ].join("\n\n")
 
   const source = [renderContentfulImports(), renderNamespace(typingsSource, namespace)].join("\n\n")
@@ -34,8 +38,8 @@ export default async function render(
   return format(source, { ...prettierConfig, parser: "typescript" })
 }
 
-function renderAllContentTypes(contentTypes: ContentType[]): string {
-  return contentTypes.map(contentType => renderContentType(contentType)).join("\n\n")
+function renderAllContentTypes(contentTypes: ContentType[], localization: boolean): string {
+  return contentTypes.map(contentType => renderContentType(contentType, localization)).join("\n\n")
 }
 
 function renderAllContentTypeIds(contentTypes: ContentType[]): string {

src/renderers/renderFieldsOnly.ts

@@ -1,6 +1,6 @@
 import { ContentType } from "contentful"
 
-import { format } from "prettier"
+import { format, resolveConfig } from "prettier"
 
 import renderContentType from "./contentful-fields-only/renderContentType"
 import renderNamespace from "./contentful/renderNamespace"
@@ -18,7 +18,9 @@ export default async function renderFieldsOnly(
   const typingsSource = renderAllContentTypes(sortedContentTypes)
   const source = [renderNamespace(typingsSource, namespace)].join("\n\n")
 
-  return format(source, { parser: "typescript" })
+  const prettierConfig = await resolveConfig(process.cwd())
+
+  return format(source, { ...prettierConfig, parser: "typescript" })
 }
 
 function renderAllContentTypes(contentTypes: ContentType[]): string {

src/renderers/typescript/renderInterfaceProperty.ts

@@ -2,14 +2,15 @@ export default function renderInterfaceProperty(
   name: string,
   type: string,
   required: boolean,
+  localization: boolean,
   description?: string,
 ): string {
   return [
     descriptionComment(description),
     name,
     required ? "" : "?",
     ": ",
-    type,
+    localization ? `LocalizedField<${type}>` : type,
     required ? "" : " | undefined",
     ";",
   ].join("")

test/renderers/contentful/renderContentType.test.ts

@@ -55,7 +55,7 @@ describe("renderContentType()", () => {
   }
 
   it("works with miscellaneous field types", () => {
-    expect(format(renderContentType(contentType))).toMatchInlineSnapshot(`
+    expect(format(renderContentType(contentType, false))).toMatchInlineSnapshot(`
             "export interface IMyContentTypeFields {
               /** Symbol Field™ */
               symbolField?: string | undefined;
@@ -84,7 +84,7 @@ describe("renderContentType()", () => {
   })
 
   it("supports descriptions", () => {
-    expect(format(renderContentType(contentTypeWithDescription))).toMatchInlineSnapshot(`
+    expect(format(renderContentType(contentTypeWithDescription, false))).toMatchInlineSnapshot(`
       "export interface IMyContentTypeFields {}
 
       /** This is a description */
@@ -107,4 +107,33 @@ describe("renderContentType()", () => {
       }"
     `)
   })
+
+  it("works with localized fields", () => {
+    expect(format(renderContentType(contentType, true))).toMatchInlineSnapshot(`
+      "export interface IMyContentTypeFields {
+        /** Symbol Field™ */
+        symbolField?: LocalizedField<string> | undefined;
+
+        /** Array field */
+        arrayField: LocalizedField<(\\"one\\" | \\"of\\" | \\"the\\" | \\"above\\")[]>;
+      }
+
+      export interface IMyContentType extends Entry<IMyContentTypeFields> {
+        sys: {
+          id: string,
+          type: string,
+          createdAt: string,
+          updatedAt: string,
+          locale: string,
+          contentType: {
+            sys: {
+              id: \\"myContentType\\",
+              linkType: \\"ContentType\\",
+              type: \\"Link\\"
+            }
+          }
+        };
+      }"
+    `)
+  })
 })

test/renderers/contentful/renderContentfulImports.test.ts

@@ -4,10 +4,19 @@ import format from "../../support/format"
 describe("renderContentfulImports()", () => {
   it("renders the top of the codegen file", () => {
     expect(format(renderContentfulImports())).toMatchInlineSnapshot(`
-"// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT MODIFY IT.
+      "// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT MODIFY IT.
 
-import { Asset, Entry } from \\"contentful\\";
-import { Document } from \\"@contentful/rich-text-types\\";"
-`)
+      import { Asset, Entry } from \\"contentful\\";
+      import { Document } from \\"@contentful/rich-text-types\\";"
+    `)
+  })
+
+  it("renders the localized top of the codegen file", () => {
+    expect(format(renderContentfulImports(true))).toMatchInlineSnapshot(`
+      "// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT MODIFY IT.
+
+      import { Entry } from \\"contentful\\";
+      import { Document } from \\"@contentful/rich-text-types\\";"
+    `)
   })
 })