@onereach/types-contacts-api 2.2.1 → 2.2.2-beta.1634.0

package/dist/{index.ts → index.d.ts}

@@ -43,12 +43,12 @@ export interface ListApiParams {
 }
 
 export interface CreateContactDto {
-  contact_book: string;
+  contact_book?: string;
   data: FieldValueRequestDto[];
 }
 
 export interface CreateMultipleContactsDto {
-  contact_book: string;
+  contact_book?: string;
   contacts: ContactRequestDto[];
 }
 
@@ -192,7 +192,8 @@ export interface UpsertFieldValueByMachineNameDto {
 
 export interface FieldValueRequestDto {
   value: any;
-  schemaId: string;
+  schemaId?: string;
+  machine_name?: string;
   id?: string;
 }
 

package/generate-types.ts

@@ -0,0 +1,195 @@
+import fs from 'fs';
+import path from 'path';
+import {
+  ClassDeclaration,
+  EnumDeclaration,
+  EnumDeclarationStructure,
+  ImportDeclaration,
+  ImportSpecifierStructure,
+  InterfaceDeclaration,
+  Project,
+  PropertyDeclaration,
+  SourceFile,
+  TypeAliasDeclaration,
+} from 'ts-morph';
+
+const ROOT = path.resolve(__dirname, './');
+const TYPES_DIST = path.resolve(ROOT, 'dist');
+const API_PATH = path.resolve(ROOT, '../api');
+const apiTsconfig = path.resolve(API_PATH, 'tsconfig.json');
+const typesTsconfig = path.resolve(ROOT, 'tsconfig.json');
+
+if (fs.existsSync(TYPES_DIST)) {
+  fs.rmSync(TYPES_DIST, { recursive: true });
+}
+fs.mkdirSync(TYPES_DIST);
+
+const typesProject = new Project({
+  tsConfigFilePath: typesTsconfig,
+});
+const apiProject = new Project({
+  tsConfigFilePath: apiTsconfig,
+});
+
+
+const FILE = typesProject.createSourceFile('./dist/index.d.ts');
+const SWAGGER_MOCK = typesProject.getSourceFile('./swagger-type-mock.ts');
+
+function generateTypes() {
+  FILE.replaceWithText(SWAGGER_MOCK?.getText() || '');
+  const [src] = apiProject.getDirectories().filter(dir => dir.getBaseName() === 'src');
+  src.getSourceFiles(['**/*.dto.ts']).forEach(sourceFile => {
+    sourceFile.getClasses().forEach(classDec => {
+      createInterfaceFrom(sourceFile, classDec);
+    });
+  });
+  FILE.formatText({ indentSize: 2 });
+  FILE.saveSync();
+}
+
+function createInterfaceFrom(
+  sourceFile: SourceFile,
+  dec: ClassDeclaration | InterfaceDeclaration,
+  isExported = true) {
+  if (dec && !hasBeenCreatedBefore(dec.getName() as string)) {
+    const interfaceDeclaration = FILE.addInterface({
+      name: dec.getName() as string,
+    });
+    const importsDeclarations = sourceFile.getImportDeclarations();
+    const structure = dec.getStructure();
+    const properties = structure.properties;
+
+    if (properties?.length) {
+      properties.forEach(p => {
+        const propertyDec = dec.getProperty(p.name as string) as PropertyDeclaration;
+        const importDec = findInImports(importsDeclarations, `${p.type}` as string);
+
+        if (importDec) {
+          sourceFile = importDec.getModuleSpecifierSourceFile() as SourceFile;
+        }
+
+        createByPropertyType(sourceFile, propertyDec);
+
+        interfaceDeclaration.addProperty({
+          name: p.name,
+          type: p.type ?? propertyDec.getType().getText(),
+          hasQuestionToken: p.hasQuestionToken,
+          isReadonly: p.isReadonly,
+        });
+      });
+    }
+
+    //check if extends is part of import
+    const extendsDef = (Array.isArray(structure.extends) ? structure.extends : [structure.extends]) as string[];
+    extendsDef.filter(Boolean).forEach((def: string) => {
+      //first check if extend has generic
+      def = def.replace(/<.*/, '');
+      const helperFunc = SWAGGER_MOCK?.getFunctions().map(f => f.getName()) || [];
+      // if extend is something like PartialType<SomeClass>
+      const hlpFn = (str: string): string => {
+        const match = /(\w+)(\(.*\))/.exec(str);
+        if (match) {
+          const fnName = match[1];
+          if (helperFunc.includes(fnName)) {
+            let args = match[2].replace(/^\(|\)$/g, '');
+            const possibleImports = args.split(',');
+            possibleImports.forEach(p => extractInterfaceFromImport(p.trim(), importsDeclarations));
+            // tuple to literal
+            const toLiteral = args.match(/(\[.*])\s*as\s*const/) || [];
+            if (toLiteral.length) {
+              const literal = (JSON.parse(toLiteral[1].replace(/'/g, '"')) as string[]).map(i => `'${i}'`).join('|');
+              args = args.replace(toLiteral[0] as string, literal);
+            }
+            return `ReturnType<typeof ${fnName}<${hlpFn(args)}>>`;
+          }
+          return str;
+        }
+        return str;
+      };
+      def = hlpFn(def);
+      extractInterfaceFromImport(def, importsDeclarations);
+
+      //if extends is part of sourceFile
+      const innerExtends = [
+        sourceFile.getClass(def),
+        sourceFile.getInterface(def),
+      ].filter(Boolean) as (ClassDeclaration | InterfaceDeclaration)[];
+
+      innerExtends.filter(Boolean).forEach(innerDef => {
+        createInterfaceFrom(sourceFile, innerDef);
+      });
+
+      interfaceDeclaration.addExtends(def);
+    });
+
+    interfaceDeclaration.setIsExported(isExported);
+  }
+}
+
+function extractInterfaceFromImport(name: string, importsDeclarations: ImportDeclaration[]) {
+  const importDec = findInImports(importsDeclarations, name);
+  // create interface if needed
+  if (importDec) {
+    const sourceFile = importDec.getModuleSpecifierSourceFile() as SourceFile;
+    createInterfaceFrom(sourceFile, sourceFile.getClass(name) as ClassDeclaration);
+  }
+}
+
+function createByPropertyType(sourceFile: SourceFile, propDec: PropertyDeclaration) {
+  const propType = propDec.getType();
+  const type = propDec.getStructure().type as string;
+  const typeAlias = sourceFile.getTypeAliases();
+
+  if (propType?.isInterface()) {
+    createInterfaceFrom(sourceFile, sourceFile.getInterface(type) as InterfaceDeclaration);
+  }
+  if (propType?.isClass()) {
+    createInterfaceFrom(sourceFile, sourceFile.getClass(type) as ClassDeclaration);
+  }
+  if (propType?.isEnum()) {
+    addEnum((sourceFile.getEnum(type) as EnumDeclaration).getStructure());
+  }
+
+  if (typeAlias) {
+    typeAlias.forEach(addTypes);
+  }
+}
+
+
+function addTypes(type: TypeAliasDeclaration) {
+  const structure = type.getStructure();
+  if (!FILE.getTypeAlias(structure.name)) {
+    FILE.addTypeAlias(type.getStructure())
+      .setIsExported(type.isExported());
+  }
+}
+
+function addEnum(enumDec: EnumDeclarationStructure) {
+  if (!FILE.getEnums().some(en => en.getName() === enumDec.name)) {
+    FILE.addEnum(enumDec);
+    enumDec.isExported = true;
+  }
+}
+
+function findInImports(imports: ImportDeclaration[], search: string): ImportDeclaration | undefined {
+  for (const imp of imports) {
+    const structure = imp.getStructure();
+    if (structure.defaultImport === search) {
+      return imp;
+    }
+    for (const named of structure.namedImports as ImportSpecifierStructure[]) {
+      if (named.name === search || named.alias === search) {
+        return imp;
+      }
+    }
+  }
+}
+
+/**
+ * checks if interface has been created before
+ */
+function hasBeenCreatedBefore(interfaceName: string): boolean {
+  return FILE.getInterfaces().some(int => int.getName() === interfaceName);
+}
+
+generateTypes();

package/package.json

@@ -1,15 +1,13 @@
 {
   "name": "@onereach/types-contacts-api",
   "description": "Generated types for Contacts Api",
-  "version": "2.2.1",
+  "version": "2.2.2-beta.1634.0",
   "author": "OneReach.ai",
-  "types": "./dist/index.ts",
+  "main": "",
+  "types": "./dist/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "dist/"
-  ],
   "scripts": {
     "build:types": "ts-node ./generate-types.ts"
   },
@@ -17,6 +15,5 @@
     "@types/node": "^18.11.10",
     "ts-morph": "^17.0.1",
     "ts-node": "^10.9.1"
-  },
-  "gitHead": "efabd933c29083d2e49a86cffa06d0dcb3ae7fff"
+  }
 }

package/swagger-type-mock.ts

@@ -0,0 +1,4 @@
+declare function OmitType<T, K extends keyof T>(classRef: T, keys: readonly K[]): Omit<T, typeof keys[number]>;
+declare function IntersectionType<A, B>(classARef: A, classBRef: B): A & B;
+declare function PartialType<T>(classRef: T): Partial<T>;
+declare function PickType<T, K extends keyof T>(classRef: T, keys: readonly K[]): Pick<T, typeof keys[number]>;

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.json",
+  "exclude": ["node_modules"],
+  "compilerOptions": {
+    "module": "commonjs",
+    "strictPropertyInitialization": false,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "baseUrl": "./",
+    "outDir": "dist",
+    "types": ["node"]
+  }
+}