@onereach/types-contacts-api 2.2.8-beta.1637.0 → 2.2.8-beta.1654.0

package/dist/index.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[];
 }
 
@@ -95,6 +95,7 @@ export interface CreateFieldSchemaDto extends MachineNameParamDto {
   singular_label?: string;
   properties?: Record<string, string>;
   type: ColumnTypes;
+  readonly?: boolean;
   schemaPresets?: SchemaPresetResponseDto[];
 }
 
@@ -174,11 +175,16 @@ export interface FieldSchemaListDto extends ListApiResponse {
   items: FieldSchemaResponseDto[];
 }
 
+export interface FieldSchemaReadonlyParamsDto {
+  readonly: boolean;
+  fields: string[];
+}
+
 export interface FieldSchemaResponseDto extends CreateFieldSchemaDto {
   id: string;
 }
 
-export interface UpdateFieldSchemaDto extends ReturnType<typeof PartialType<ReturnType<typeof OmitType<CreateFieldSchemaDto, 'type' | 'machine_name'>>>> {
+export interface UpdateFieldSchemaDto extends ReturnType<typeof PartialType<ReturnType<typeof OmitType<CreateFieldSchemaDto, 'type' | 'machine_name' | 'readonly'>>>> {
 }
 
 export interface DeleteFieldValueByMachineNameDto extends ReturnType<typeof OmitType<UpsertFieldValueByMachineNameDto, 'value'>> {
@@ -192,8 +198,7 @@ export interface UpsertFieldValueByMachineNameDto {
 
 export interface FieldValueRequestDto {
   value: any;
-  schemaId?: string;
-  machine_name?: string;
+  schemaId: string;
   id?: string;
 }
 

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@onereach/types-contacts-api",
   "description": "Generated types for Contacts Api",
-  "version": "2.2.8-beta.1637.0",
+  "version": "2.2.8-beta.1654.0",
   "author": "OneReach.ai",
-  "main": "./dist/index.ts",
+  "types": "./dist/index.ts",
   "publishConfig": {
     "access": "public"
   },
+  "files": [
+    "dist/"
+  ],
   "scripts": {
     "build:types": "ts-node ./generate-types.ts"
   },

package/generate-types.ts

@@ -1,195 +0,0 @@
-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.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/swagger-type-mock.ts

@@ -1,4 +0,0 @@
-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

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