flag based approach for referenced entries

Author: naman-contentstack

src/generateTS/factory.ts

@@ -17,6 +17,7 @@ export type TSGenOptions = {
   };
   systemFields?: boolean;
   isEditableTags?: boolean;
+  includeReferencedEntry?: boolean;
 };
 
 export type TSGenResult = {
@@ -73,6 +74,7 @@ const defaultOptions: TSGenOptions = {
   },
   systemFields: false,
   isEditableTags: false,
+  includeReferencedEntry: false,
 };
 
 export default function (userOptions: TSGenOptions) {
@@ -525,20 +527,29 @@ export default function (userOptions: TSGenOptions) {
       return "Record<string, unknown>[]";
     }
 
-    // Use the ReferencedEntry interface from builtins
-    const referencedEntryType = `${options.naming?.prefix || ""}ReferencedEntry`;
+    // Conditionally use the ReferencedEntry interface from builtins
+    if (options.includeReferencedEntry) {
+      const referencedEntryType = `${options.naming?.prefix || ""}ReferencedEntry`;
 
-    // If there's only one reference type, create a simple union
-    if (references.length === 1) {
-      return `(${references[0]} | ${referencedEntryType})[]`;
-    }
+      // If there's only one reference type, create a simple union
+      if (references.length === 1) {
+        return `(${references[0]} | ${referencedEntryType})[]`;
+      }
 
-    // If there are multiple reference types, create separate unions for each
-    const unionTypes = references.map((refType) => {
-      return `(${refType} | ${referencedEntryType})`;
-    });
+      // If there are multiple reference types, create separate unions for each
+      const unionTypes = references.map((refType) => {
+        return `(${refType} | ${referencedEntryType})`;
+      });
 
-    return `${unionTypes.join(" | ")}[]`;
+      return `${unionTypes.join(" | ")}[]`;
+    } else {
+      // If ReferencedEntry is disabled, just use the reference types directly
+      if (references.length === 1) {
+        return `${references[0]}[]`;
+      }
+
+      return `${references.join(" | ")}[]`;
+    }
   }
 
   return function (

src/generateTS/index.ts

@@ -2,7 +2,11 @@ import async from "async";
 import { flatMap, flatten } from "lodash";
 import { TOKEN_TYPE } from "../constants";
 import { initializeContentstackSdk } from "../sdk/utils";
-import { GenerateTS, GenerateTSFromContentTypes } from "../types";
+import {
+  GenerateTS,
+  GenerateTSBase,
+  GenerateTSFromContentTypes,
+} from "../types";
 import * as fs from "fs";
 import { DocumentationGenerator } from "./docgen/doc";
 import JSDocumentationGenerator from "./docgen/jsdoc";
@@ -24,6 +28,7 @@ export const generateTS = async ({
   includeDocumentation,
   systemFields,
   isEditableTags,
+  includeReferencedEntry,
   host,
 }: GenerateTS) => {
   try {
@@ -88,6 +93,7 @@ export const generateTS = async ({
           includeDocumentation,
           systemFields,
           isEditableTags,
+          includeReferencedEntry,
         });
         return generatedTS;
       }
@@ -141,6 +147,7 @@ export const generateTSFromContentTypes = async ({
   includeDocumentation = true,
   systemFields = false,
   isEditableTags = false,
+  includeReferencedEntry = false,
 }: GenerateTSFromContentTypes) => {
   try {
     const docgen: DocumentationGenerator = includeDocumentation
@@ -154,6 +161,7 @@ export const generateTSFromContentTypes = async ({
       naming: { prefix },
       systemFields,
       isEditableTags,
+      includeReferencedEntry,
     });
     for (const contentType of contentTypes) {
       const tsgenResult = tsgen(contentType);
@@ -180,7 +188,8 @@ export const generateTSFromContentTypes = async ({
           prefix,
           systemFields,
           isEditableTags,
-          hasJsonField
+          hasJsonField,
+          includeReferencedEntry
         ).join("\n\n"),
         [...globalFields].join("\n\n"),
         definitions.join("\n\n"),
@@ -257,3 +266,31 @@ const checkJsonField = (schema: any[]): boolean => {
     return false;
   });
 };
+
+const fun = async () => {
+  try {
+    const config: GenerateTSBase = {
+      apiKey: "***REMOVED***",
+      token: "***REMOVED***",
+      environment: "dev",
+      tokenType: "delivery",
+      region: "AWS-NA",
+      includeDocumentation: false,
+      systemFields: true,
+      includeReferencedEntry: true,
+      // isEditableTags: true,
+      // host: "stag-cdn.csnonprod.com",
+      branch: "main",
+    };
+
+    const val = await generateTS(config);
+    fs.writeFileSync(
+      "/Users/naman.dembla/Documents/TS-GEN/types-generator/generated.ts",
+      JSON.parse(JSON.stringify(val)),
+      "utf-8"
+    );
+  } catch (err: any) {
+    console.log("🚀 ~ fun ~ err:", err);
+  }
+};
+fun();

src/generateTS/stack/builtins.ts

@@ -4,24 +4,36 @@ export const defaultInterfaces = (
   prefix = "",
   systemFields = false,
   isEditableTags = false,
-  hasJsonRte?: boolean
+  hasJsonRte?: boolean,
+  includeReferencedEntry = false
 ) => {
   const defaultInterfaces = [
     `type BuildTuple<T, N extends number, R extends T[] = []> =
     R['length'] extends N ? R : BuildTuple<T, N, [...R, T]>`,
     `type TuplePrefixes<T extends any[]> = 
     T extends [any, ...infer Rest] ? T | TuplePrefixes<Rest extends any[] ? Rest : []> : []`,
     `type MaxTuple<T, N extends number> = TuplePrefixes<BuildTuple<T, N>>`,
-    `export interface ${prefix}ReferencedEntry {
+  ];
+
+  // Conditionally include ReferencedEntry interface
+  if (includeReferencedEntry) {
+    defaultInterfaces.push(
+      `export interface ${prefix}ReferencedEntry {
             uid: string;
             _content_type_uid: string;
-        }`,
+        }`
+    );
+  }
+
+  defaultInterfaces.push(
     `export interface ${prefix}PublishDetails {
             environment: string;
             locale: string;
             time: string;
             user: string;
-        }`,
+        }`
+  );
+  defaultInterfaces.push(
     `export interface ${prefix}File { 
               uid: string;
               created_at: string;
@@ -45,19 +57,25 @@ export const defaultInterfaces = (
                 width: number;
             }
               publish_details: ${prefix}PublishDetails;
-          }`,
+          }`
+  );
+  defaultInterfaces.push(
     `export interface ${prefix}Link { 
               title: string;
               href: string;
-          }`,
+          }`
+  );
+  defaultInterfaces.push(
     `export interface ${prefix}Taxonomy { 
             taxonomy_uid: string;
             max_terms?: number;
             mandatory: boolean;
             non_localizable: boolean;
-        }`,
-    `export type ${prefix}TaxonomyEntry = ${prefix}Taxonomy & { term_uid: string }`,
-  ];
+        }`
+  );
+  defaultInterfaces.push(
+    `export type ${prefix}TaxonomyEntry = ${prefix}Taxonomy & { term_uid: string }`
+  );
   if (hasJsonRte) {
     defaultInterfaces.push(
       `export interface JSONRTENode {

src/types/index.ts

@@ -24,6 +24,7 @@ export interface GenerateTSBase extends StackConnectionConfig {
   includeDocumentation?: boolean;
   systemFields?: boolean;
   isEditableTags?: boolean;
+  includeReferencedEntry?: boolean;
 }
 
 export type GenerateTS = GenerateTSBase;
@@ -38,4 +39,5 @@ export interface GenerateTSFromContentTypes {
   includeDocumentation?: boolean;
   systemFields?: boolean;
   isEditableTags?: boolean;
+  includeReferencedEntry?: boolean;
 }

tests/integration/generateTS/generateTS.test.ts

@@ -111,12 +111,58 @@ describe("generateTS function", () => {
     });
 
     expect(generatedTS).toEqual(expect.stringContaining("interface")); // Check for Output is not undefined
-    expect(generatedTS).toMatch(/export interface CSLPAttribute/); // Check for CSLP attribute interface is created
-    expect(generatedTS).toMatch(/export type CSLPFieldMapping/); // Check for CSLP field mapping type is created
+    expect(generatedTS).toMatch(/Dishes/); // Check for whether typeDef of Content type is included
+    expect(generatedTS).toMatch(/export interface CSLPAttribute/); // Check for whether CSLP attribute interface is created
+    expect(generatedTS).toMatch(/export type CSLPFieldMapping/); // Check for whether CSLP field mapping type is created
     expect(generatedTS).toMatch(/\$\?\:/); // Check for editable field mappings with $ property
     expect(generatedTS).toMatch(/\?\: CSLPFieldMapping/); // Check for individual field CSLP mappings
     expect(generatedTS).toMatch(/\/\*\*.*\*\/\n\s*(export)/); // Check for Documentation is generated
   });
+
+  it("generates type definitions with ReferencedEntry enabled", async () => {
+    const token = process.env.TOKEN as unknown as any;
+    const apiKey = process.env.APIKEY as unknown as any;
+    const environment = process.env.ENVIRONMENT as unknown as any;
+    const region = process.env.REGION as unknown as any;
+    const tokenType = process.env.TOKENTYPE as unknown as any;
+    const includeReferencedEntry = true;
+
+    const generatedTS = await generateTS({
+      token,
+      apiKey,
+      environment,
+      region,
+      tokenType,
+      includeReferencedEntry,
+    });
+
+    expect(generatedTS).toEqual(expect.stringContaining("interface")); // Check for Output is not undefined
+    expect(generatedTS).toEqual(expect.stringContaining("Dishes")); // Check for whether typeDef of Content type is included
+    expect(generatedTS).toMatch(/ReferencedEntry/); // Check that ReferencedEntry interface is included
+    expect(generatedTS).toMatch(/\/\*\*.*\*\/\n\s*(export)/); // Check for Documentation is generated
+  });
+
+  it("generates type definitions without ReferencedEntry (default)", async () => {
+    const token = process.env.TOKEN as unknown as any;
+    const apiKey = process.env.APIKEY as unknown as any;
+    const environment = process.env.ENVIRONMENT as unknown as any;
+    const region = process.env.REGION as unknown as any;
+    const tokenType = process.env.TOKENTYPE as unknown as any;
+    // Don't pass includeReferencedEntry, should default to false
+
+    const generatedTS = await generateTS({
+      token,
+      apiKey,
+      environment,
+      region,
+      tokenType,
+    });
+
+    expect(generatedTS).toEqual(expect.stringContaining("interface")); // Check for Output is not undefined
+    expect(generatedTS).toEqual(expect.stringContaining("Dishes")); // Check for whether typeDef of Content type is included
+    expect(generatedTS).not.toMatch(/ReferencedEntry/); // Check that ReferencedEntry interface is not included
+    expect(generatedTS).toMatch(/\/\*\*.*\*\/\n\s*(export)/); // Check for Documentation is generated
+  });
 });
 
 describe("generateTS function with errors", () => {

tests/unit/tsgen/references.test.ts

@@ -10,27 +10,70 @@ const tsgen = tsgenFactory({
   },
 });
 
+const tsgenWithReferencedEntry = tsgenFactory({
+  docgen: new NullDocumentationGenerator(),
+  naming: {
+    prefix: "I",
+  },
+  includeReferencedEntry: true,
+});
+
 describe("references", () => {
-  const result = tsgen(testData.references);
+  describe("with ReferencedEntry disabled (default)", () => {
+    const result = tsgen(testData.references);
+
+    test("metadata", () => {
+      const contentTypes = [...result.metadata.dependencies.contentTypes];
 
-  test("metadata", () => {
-    const contentTypes = [...result.metadata.dependencies.contentTypes];
+      expect(contentTypes).toEqual(
+        expect.arrayContaining([
+          "IReferenceChild",
+          "IBoolean",
+          "IBuiltinExample",
+        ])
+      );
+    });
 
-    expect(contentTypes).toEqual(
-      expect.arrayContaining(["IReferenceChild", "IBoolean", "IBuiltinExample"])
-    );
+    test("definition", () => {
+      expect(result.definition).toMatchInlineSnapshot(`
+        "export interface IReferenceParent
+        {
+        _version?: number;
+        title: string;
+        url: string;
+        single_reference: IReferenceChild[];
+        multiple_reference?: IReferenceChild | IBoolean | IBuiltinExample[];
+        }"
+      `);
+    });
   });
 
-  test("definition", () => {
-    expect(result.definition).toMatchInlineSnapshot(`
-      "export interface IReferenceParent
-      {
-      _version?: number;
-      title: string;
-      url: string;
-      single_reference: (IReferenceChild | IReferencedEntry)[];
-      multiple_reference?: (IReferenceChild | IReferencedEntry) | (IBoolean | IReferencedEntry) | (IBuiltinExample | IReferencedEntry)[];
-      }"
-    `);
+  describe("with ReferencedEntry enabled", () => {
+    const result = tsgenWithReferencedEntry(testData.references);
+
+    test("metadata", () => {
+      const contentTypes = [...result.metadata.dependencies.contentTypes];
+
+      expect(contentTypes).toEqual(
+        expect.arrayContaining([
+          "IReferenceChild",
+          "IBoolean",
+          "IBuiltinExample",
+        ])
+      );
+    });
+
+    test("definition", () => {
+      expect(result.definition).toMatchInlineSnapshot(`
+        "export interface IReferenceParent
+        {
+        _version?: number;
+        title: string;
+        url: string;
+        single_reference: (IReferenceChild | IReferencedEntry)[];
+        multiple_reference?: (IReferenceChild | IReferencedEntry) | (IBoolean | IReferencedEntry) | (IBuiltinExample | IReferencedEntry)[];
+        }"
+      `);
+    });
   });
 });