@cerema/cadriciel 1.4.23 → 1.4.26

package/aqtion/.cadriciel/bin/gen/db/ext/models.js

@@ -0,0 +1,843 @@
+module.exports = (args) => {
+  /**
+   * generate models
+   */
+
+  const { Sequelize } = require('sequelize');
+  const exec = require('child_process').exec;
+  const ora = require('ora');
+  const path = require('path');
+  const fs = require('fs');
+
+  const dir = __dirname + '/../../../../../backend';
+  const data_dir = fs.readdirSync(dir);
+  const commondir = 'main/java/fr/cerema/dsi';
+  const commondot = commondir.replace(/\//g, '.').split('main.java.')[1];
+
+  try {
+    var SETUP = fs.readFileSync(`${__dirname}/../../../../.uuid`, 'utf-8');
+  } catch (e) {
+    console.log(
+      chalk.bold('  [ENV] ') +
+        chalk.red(" Votre environnement n'est pas démarré.")
+    );
+    return process.exit(1);
+  }
+  require('dotenv').config({
+    path: `${__dirname}/../../../../../docker/${SETUP}/.env`,
+  });
+
+  let data = data_dir.find((item) => item.includes('-data'));
+  const schema = data.split('-data')[0];
+
+  const uri = `postgres://${process.env.POSTGRES_USER}:${process.env.POSTGRES_PASSWORD}@localhost:${process.env.POSTGRES_DEV_PORT}/${process.env.POSTGRES_DB}`;
+  const sequelize = new Sequelize(uri, {
+    logging: false,
+  });
+
+  try {
+    var INSTALLED_FILES = JSON.parse(
+      fs.readFileSync(`${__dirname}/../../../../shared/models.cache`, 'utf-8')
+    );
+    for (let i = 0; i < INSTALLED_FILES.length; i++) {
+      try {
+        fs.unlinkSync(INSTALLED_FILES[i]);
+      } catch (e) {}
+    }
+    INSTALLED_FILES = [];
+  } catch (e) {
+    var INSTALLED_FILES = [];
+  }
+
+  const PG_TO_TS_TYPES = {
+    // Numeric types
+    smallint: 'number',
+    integer: 'number',
+    bigint: 'number',
+    decimal: 'number',
+    numeric: 'number',
+    real: 'number',
+    'double precision': 'number',
+    serial: 'number',
+    bigserial: 'number',
+    money: 'number',
+
+    // Character types
+    'character varying': 'string',
+    varchar: 'string',
+    character: 'string',
+    char: 'string',
+    text: 'string',
+
+    // Binary data types
+    bytea: 'any', // This could be mapped to a Buffer in Node.js, but "any" for generic TypeScript
+
+    // Date and time types
+    timestamp: 'Date',
+    'timestamp without time zone': 'Date',
+    'timestamp with time zone': 'Date',
+    date: 'Date',
+    time: 'string', // Considered string because managing time only as Date in JS might be misleading
+    'time without time zone': 'string',
+    'time with time zone': 'string',
+    interval: 'any',
+
+    // Boolean type
+    boolean: 'boolean',
+
+    // Enumerated types
+    // These will be tricky because you'll have to get all possible values for the enum, might be better handled individually
+    enum: 'string',
+
+    // Geometric types
+    point: 'any',
+    line: 'any',
+    lseg: 'any',
+    box: 'any',
+    path: 'any',
+    polygon: 'any',
+    circle: 'any',
+
+    // Network address types
+    cidr: 'string',
+    inet: 'string',
+    macaddr: 'string',
+    macaddr8: 'string',
+
+    // Bit strings
+    bit: 'any',
+    'bit varying': 'any',
+
+    // Text search types
+    tsvector: 'any',
+    tsquery: 'any',
+
+    // UUID type
+    uuid: 'string',
+
+    // JSON types
+    json: 'any',
+    jsonb: 'any',
+
+    // Array types
+    // Needs special handling as the underlying type matters, but for simplification:
+    _int4: 'number[]', // Example for integer array
+    _text: 'string[]', // Example for text array
+
+    // Others
+    oid: 'number',
+    cid: 'number',
+    xid: 'number',
+    tid: 'number',
+  };
+
+  const toCamelCase = (str) => {
+    return str.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
+  };
+  const toPascalCase = (str) => {
+    return str
+      .replace(/\w+/g, function (word) {
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+      })
+      .replace(/_([a-z])/g, function (g) {
+        return g[1].toUpperCase();
+      });
+  };
+
+  const entities_header = `package ${commondot}.${schema}.entities;`;
+
+  // generate enums
+  const SQL = `
+SELECT t.typname AS enum_name, 
+       e.enumlabel AS enum_value
+FROM pg_type t 
+JOIN pg_enum e ON t.oid = e.enumtypid  
+JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace 
+WHERE n.nspname = '${schema}'
+ORDER BY t.typname, e.enumlabel;
+`;
+
+  const createEnums = async (cb) => {
+    const data = await sequelize.query(SQL);
+    let dir = `${__dirname}/../../../../../backend/${schema}-transverse`;
+    dir += `/src/${commondir}/${schema}/enums`;
+    if (data[0].length === 0) return cb();
+    let enum_name = data[0][0].enum_name;
+    let filename = `${dir}/${toPascalCase(data[0][0].enum_name)}.java`;
+    const className = commondot + '.' + schema + '.enums';
+    let package = [
+      `package ${className};`,
+      ` `,
+      `public enum ${toPascalCase(data[0][0].enum_name)} {`,
+    ];
+    for (let i = 0; i < data[0].length; i++) {
+      let newfilename = `${dir}/${toPascalCase(data[0][i].enum_name)}.java`;
+      if (newfilename !== filename) {
+        package.push('}');
+        fs.writeFileSync(filename, package.join('\n'));
+        INSTALLED_FILES.push(filename);
+        filename = newfilename;
+        package = [
+          `package ${className};`,
+          ` `,
+          `public enum ${toPascalCase(data[0][i].enum_name)} {`,
+        ];
+      }
+      package.push('  ' + data[0][i].enum_value + ',');
+    }
+    package.push('}');
+    fs.writeFileSync(filename, package.join('\n'));
+    INSTALLED_FILES.push(filename);
+    cb();
+  };
+
+  const getTableComposition = async (schemaName) => {
+    let query = `WITH primary_keys AS (
+    SELECT 
+        kcu.table_name,
+        kcu.column_name
+    FROM 
+        information_schema.table_constraints tc
+    JOIN 
+        information_schema.key_column_usage kcu 
+        ON tc.constraint_name = kcu.constraint_name
+    WHERE 
+        tc.constraint_type = 'PRIMARY KEY'
+        AND tc.table_schema = :schemaName
+),
+
+foreign_keys AS (
+    SELECT
+        kcu.table_name,
+        kcu.column_name,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name
+    FROM
+        information_schema.table_constraints tc
+    JOIN 
+        information_schema.key_column_usage kcu 
+        ON tc.constraint_name = kcu.constraint_name
+    JOIN 
+        information_schema.constraint_column_usage ccu 
+        ON tc.constraint_name = ccu.constraint_name
+    WHERE 
+        tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_schema = :schemaName
+),
+sequence_info AS (
+  SELECT
+      schemaname AS sequence_schema,
+      sequencename AS sequence_name,
+      increment_by AS allocation_size
+  FROM
+      pg_sequences
+)
+
+SELECT 
+    tbl.table_schema,
+    tbl.table_name,
+    a.attname AS field_name,
+    format_type(a.atttypid, a.atttypmod) AS data_type,
+    CASE 
+        WHEN pk.column_name IS NOT NULL THEN 'YES' 
+        ELSE 'NO' 
+    END AS is_primary_key,
+    fk.foreign_table_name,
+    fk.foreign_column_name,
+    seq.sequence_name,
+    seq.allocation_size,
+    CASE 
+        WHEN a.attnotnull THEN 'YES' 
+        ELSE 'NO' 
+    END AS is_required  -- This column indicates if the field is required or not
+FROM 
+    information_schema.tables tbl
+JOIN 
+    pg_attribute a 
+    ON tbl.table_name::regclass = a.attrelid
+LEFT JOIN 
+    primary_keys pk 
+    ON tbl.table_name = pk.table_name AND a.attname = pk.column_name
+LEFT JOIN
+    foreign_keys fk
+    ON tbl.table_name = fk.table_name AND a.attname = fk.column_name
+LEFT JOIN 
+    sequence_info seq 
+    ON SPLIT_PART(pg_get_serial_sequence(tbl.table_name, a.attname), '.', 2) = seq.sequence_name 
+    AND SPLIT_PART(pg_get_serial_sequence(tbl.table_name, a.attname), '.', 1) = seq.sequence_schema
+WHERE 
+    a.attnum > 0 
+    AND NOT a.attisdropped 
+    AND tbl.table_schema = :schemaName
+    AND tbl.table_type = 'BASE TABLE'
+    AND tbl.table_name not in ('flyway_schema_history','users','profil')
+ORDER BY 
+    tbl.table_name, 
+    a.attname;`;
+    try {
+      const result = await sequelize.query(query, {
+        replacements: { schemaName },
+        type: Sequelize.QueryTypes.SELECT,
+      });
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch table composition:', error);
+    }
+  };
+
+  function postgresToTypeScript(dataType) {
+    if (
+      dataType.startsWith('character varying(') ||
+      dataType.startsWith('character(')
+    ) {
+      return 'string';
+    }
+
+    if (dataType.startsWith('numeric(') || dataType.startsWith('decimal(')) {
+      return 'number';
+    }
+
+    if (dataType.startsWith('timestamp(') || dataType.startsWith('time(')) {
+      return 'Date'; // or 'string' depending on how you handle dates in TypeScript
+    }
+
+    switch (dataType) {
+      case 'integer':
+      case 'smallint':
+      case 'serial':
+      case 'smallserial':
+        return 'number';
+
+      case 'bigint':
+      case 'bigserial':
+        return 'number';
+
+      case 'numeric':
+      case 'real':
+      case 'double precision':
+        return 'number';
+
+      case 'boolean':
+        return 'boolean';
+
+      case 'character varying':
+      case 'character':
+        return 'string';
+
+      default:
+        return 'any'; // or throw an error if you want to ensure all types are explicitly mapped
+    }
+  }
+
+  const mapFieldWithoutPrefix = (items) => {
+    let result = {};
+
+    const groupedByTable = items.reduce((acc, item) => {
+      if (!acc[item.table_name]) {
+        acc[item.table_name] = [];
+      }
+      acc[item.table_name].push(item.field_name);
+      return acc;
+    }, {});
+
+    for (const [tableName, fields] of Object.entries(groupedByTable)) {
+      result[tableName] = {};
+
+      // Trouver le champ ayant le plus de caractères communs avec le nom de la table
+      const matchingPrefixField = fields.reduce(
+        (bestMatch, currentField) => {
+          const commonLength = [...tableName].filter(
+            (char, i) => char === currentField[i]
+          ).length;
+          return commonLength > bestMatch.commonLength
+            ? { fieldName: currentField, commonLength }
+            : bestMatch;
+        },
+        { fieldName: '', commonLength: 0 }
+      ).fieldName;
+
+      const underscoreIndex = matchingPrefixField.lastIndexOf('_');
+      const prefix =
+        underscoreIndex !== -1
+          ? matchingPrefixField.substring(0, underscoreIndex + 1)
+          : '';
+
+      fields.forEach((fieldName) => {
+        if (fieldName.startsWith(prefix)) {
+          result[tableName][fieldName] = fieldName.replace(prefix, '');
+        } else {
+          result[tableName][fieldName] = fieldName;
+        }
+      });
+    }
+
+    return result;
+  };
+
+  const createClientInterface = (cb) => {
+    getTableComposition(schema).then((result) => {
+      if (result.length === 0) return cb();
+      const fieldNames = mapFieldWithoutPrefix(result);
+      let table = result[0].table_name;
+      let imports = [];
+      let iface = ['export interface ' + toPascalCase(table) + ' {'];
+      let ifaceDTO = ['export interface ' + toPascalCase(table) + 'DTO {'];
+      for (let i = 0; i < result.length; i++) {
+        if (table != result[i].table_name) {
+          if (imports.length > 0) {
+            for (let k = 0; k < imports.length; k++) {
+              iface.splice(
+                0,
+                0,
+                `import { ${imports[k]}, ${imports[k]}DTO } from './${imports[k]}';`
+              );
+            }
+            iface.splice(imports.length, 0, ' ');
+          }
+          iface.push('}');
+          ifaceDTO.push('}');
+          fs.writeFileSync(
+            `${__dirname}/../../../../../frontend/app/interfaces/${toPascalCase(
+              table
+            )}.ts`,
+            iface.join('\n') + '\n\n' + ifaceDTO.join('\n')
+          );
+          INSTALLED_FILES.push(
+            `${__dirname}/../../../../../frontend/app/interfaces/${toPascalCase(
+              table
+            )}.ts`
+          );
+          table = result[i].table_name;
+          imports = [];
+          iface = ['export interface ' + toPascalCase(table) + ' {'];
+          ifaceDTO = ['export interface ' + toPascalCase(table) + 'DTO {'];
+        }
+        const fieldName = result[i].field_name;
+        if (result[i].is_primary_key === 'YES') {
+          iface.splice(
+            1,
+            0,
+            `  id: ${postgresToTypeScript(result[i].data_type)};`
+          );
+          ifaceDTO.splice(
+            1,
+            0,
+            `  id?: ${postgresToTypeScript(result[i].data_type)};`
+          );
+        } else {
+          if (result[i].foreign_table_name) {
+            let pfxnull = ' | null';
+            let fld = toCamelCase(result[i].field_name.split('_')[0]);
+            ifaceDTO.push(
+              `  ${fld}?: ${toPascalCase(result[i].foreign_table_name)}DTO;`
+            );
+            if (result[i].is_required === 'NO') {
+              fld += '?';
+            } else pfxnull = '';
+            iface.push(
+              `  ${fld}: ${toPascalCase(
+                result[i].foreign_table_name
+              )}${pfxnull};`
+            );
+            if (result[i].foreign_table_name != result[i].table_name)
+              imports.push(toPascalCase(result[i].foreign_table_name));
+          } else {
+            let fld = toCamelCase(fieldNames[table][result[i].field_name]);
+            ifaceDTO.push(
+              `  ${fld}?: ${postgresToTypeScript(result[i].data_type)};`
+            );
+            if (result[i].is_required === 'NO') fld += '?';
+            iface.push(
+              `  ${fld}: ${postgresToTypeScript(result[i].data_type)};`
+            );
+          }
+        }
+      }
+      if (imports.length > 0) {
+        for (let k = 0; k < imports.length; k++) {
+          iface.splice(
+            0,
+            0,
+            `import { ${imports[k]}, ${imports[k]}DTO } from './${imports[k]}';`
+          );
+        }
+        iface.splice(imports.length, 0, ' ');
+      }
+      iface.push('}');
+      ifaceDTO.push('}');
+      fs.writeFileSync(
+        `${__dirname}/../../../../../frontend/app/interfaces/${toPascalCase(
+          table
+        )}.ts`,
+        iface.join('\n') + '\n\n' + ifaceDTO.join('\n')
+      );
+      INSTALLED_FILES.push(
+        `${__dirname}/../../../../../frontend/app/interfaces/${toPascalCase(
+          table
+        )}.ts`
+      );
+      cb();
+    });
+  };
+
+  const generateJavaToString = (table, columns) => {
+    let result = `return "${table}{" +\n`;
+
+    for (let i = 0; i < columns.length; i++) {
+      if (typeof columns[i] === 'string') {
+        result += `        "${columns[i]}=" + ${columns[i]}`;
+        if (i !== columns.length - 1) {
+          result += ' +\n';
+        }
+      }
+    }
+
+    result += ' + "}";';
+    return result;
+  };
+
+  const jmapping = {
+    text: 'String',
+    character: 'String',
+    character_varying: 'String',
+    'character varying': 'String',
+    cidr: 'String',
+    inet: 'String',
+    json: 'String',
+    jsonb: 'String',
+    uuid: 'String',
+    smallint: 'Short',
+    int2: 'Short',
+    integer: 'Integer',
+    int4: 'Integer',
+    bigint: 'Long',
+    int8: 'Long',
+    'double precision': 'Double',
+    float8: 'Double',
+    real: 'Float',
+    float4: 'Float',
+    boolean: 'Boolean',
+    bytea: 'byte[]',
+    timestamp: 'Date',
+    timestamptz: 'Date',
+    date: 'LocalDate',
+    time: 'LocalTime',
+    timetz: 'LocalTime',
+    numeric: 'BigDecimal',
+    decimal: 'BigDecimal',
+    interval: 'Duration',
+    money: 'BigDecimal',
+    'integer[]': 'List<Integer>',
+    'text[]': 'List<String>',
+  };
+
+  const JMap = (o) => {
+    if (o.includes('character')) {
+      return 'String';
+    } else return jmapping[o];
+  };
+
+  const createEntities = async (cb) => {
+    const createCompositeKeyClass = (tbl, fields) => {
+      let dir = `${__dirname}/../../../../../backend/${schema}-transverse`;
+      dir += `/src/${commondir}/${schema}/entities/keys`;
+      try {
+        fs.mkdirSync(dir);
+      } catch (e) {}
+      const filename = `${dir}/${toPascalCase(tbl)}Key.java`;
+      fs.writeFileSync(filename, fields.join('\n'));
+      INSTALLED_FILES.push(filename);
+    };
+    let imports = new Set([
+      'javax.validation.constraints.NotNull',
+      'java.io.Serializable',
+      commondot + '.commons.entities.GenericEntity',
+      'jakarta.persistence.*',
+      'com.fasterxml.jackson.annotation.JsonProperty',
+      'lombok.*',
+    ]);
+    const javaTypeImport = {
+      Date: 'java.util.Date',
+      LocalDate: 'java.time.LocalDate',
+      LocalTime: 'java.time.LocalTime',
+      LocalDateTime: 'java.time.LocalDateTime',
+      OffsetDateTime: 'java.time.OffsetDateTime',
+      ZonedDateTime: 'java.time.ZonedDateTime',
+      Duration: 'java.time.Duration',
+      BigDecimal: 'java.math.BigDecimal',
+      'List<Integer>': 'java.util.List',
+      'List<String>': 'java.util.List',
+      'List<Employees>': 'java.util.List',
+    };
+    const generateHeader = (tableName, imports) => {
+      let header = [];
+      header.push(entities_header);
+      header.push(' ');
+      for (let i of imports) {
+        header.push(`import ${i};`);
+      }
+      header.push(' ');
+      return header;
+    };
+    const isCompositeKey = (table, result) => {
+      const primaryKeys = result.filter(
+        (row) => row.table_name === table && row.is_primary_key === 'YES'
+      );
+      return primaryKeys.length > 1;
+    };
+    const primaryKeys = (table, result) => {
+      const primaryKeys = result.filter(
+        (row) => row.table_name === table && row.is_primary_key === 'YES'
+      );
+      return primaryKeys;
+    };
+    const createEntity = (tbl, imports, fields) => {
+      let header = generateHeader(tbl, imports);
+      let dir = `${__dirname}/../../../../../backend/${schema}-transverse`;
+      dir += `/src/${commondir}/${schema}/entities`;
+      const filename = `${dir}/${toPascalCase(tbl)}.java`;
+      fields.push('}');
+      let entityContent = header.concat(fields);
+      fs.writeFileSync(filename, entityContent.join('\n'));
+      INSTALLED_FILES.push(filename);
+    };
+    const detectMostCommonPrefix = (fields) => {
+      const prefixCounts = {};
+
+      for (let field of fields) {
+        const parts = field.split('_');
+        if (parts.length > 1) {
+          const prefix = parts[0];
+          prefixCounts[prefix] = (prefixCounts[prefix] || 0) + 1;
+        }
+      }
+
+      let mostCommonPrefix = null;
+      let maxCount = 0;
+      for (let prefix in prefixCounts) {
+        if (prefixCounts[prefix] > maxCount) {
+          maxCount = prefixCounts[prefix];
+          mostCommonPrefix = prefix;
+        }
+      }
+
+      // Vérifier si tous les champs contiennent le préfixe le plus courant
+      for (let field of fields) {
+        if (!field.startsWith(mostCommonPrefix + '_')) {
+          return null;
+        }
+      }
+
+      return mostCommonPrefix;
+    };
+    const removeTablePrefix = (fieldName, prefix) => {
+      if (!prefix) return fieldName;
+      if (prefix && fieldName.startsWith(prefix + '_')) {
+        return fieldName.substring(prefix.length + 1);
+      }
+      return fieldName;
+    };
+
+    const result = await getTableComposition(schema);
+
+    let currentTable = result[0].table_name;
+    let fields = [];
+    fields.push(`@Data`);
+    fields.push(`@EqualsAndHashCode(callSuper=false)`);
+    fields.push(`@Entity`);
+    fields.push(`@Table(name = "${currentTable}")`);
+    fields.push(
+      'public class ' + toPascalCase(currentTable) + ' extends GenericEntity {'
+    );
+    fields.push(' ');
+
+    let zmap = {};
+
+    for (let i = 0; i < result.length; i++) {
+      if (isCompositeKey(currentTable, result)) {
+        imports.add('jakarta.persistence.Embeddable');
+        imports.add('jakarta.persistence.EmbeddedId');
+        imports.add(`${commondot}.${schema}.entities.keys.*`);
+        const keyFields = primaryKeys(currentTable, result).map((pk) => {
+          return `   @Column(name = "${pk.field_name}")\n   private ${JMap(
+            pk.data_type
+          )} ${toCamelCase(pk.field_name)};\n`;
+        });
+        keyFields.unshift(
+          `package ${commondot}.${schema}.entities.keys;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Embeddable;
+import java.io.Serializable;
+import java.util.Objects;
+          `,
+          `@Embeddable`,
+          'public class ' +
+            toPascalCase(currentTable) +
+            'Key implements Serializable {\n'
+        );
+        //
+        keyFields.push(' ');
+        keyFields.push('   public ' + toPascalCase(currentTable) + 'Key() {}');
+        const pks = primaryKeys(currentTable, result);
+        for (let k = 0; k < pks.length; k++) {
+          const pk = pks[k];
+          keyFields.push(`
+   public ${JMap(pk.data_type)} get${toPascalCase(pk.field_name)}() {
+      return ${toCamelCase(pk.field_name)};
+   }
+   public void set${toPascalCase(pk.field_name)}(${JMap(
+            pk.data_type
+          )} ${toCamelCase(pk.field_name)}) {
+      this.${toCamelCase(pk.field_name)} = ${toCamelCase(pk.field_name)};
+   }`);
+        }
+
+        keyFields.push('}');
+        createCompositeKeyClass(currentTable, keyFields);
+        if (
+          fields.indexOf(`private ${toPascalCase(currentTable)}Key id;`) == -1
+        ) {
+          fields.push(`@EmbeddedId`);
+          fields.push(`private ${toPascalCase(currentTable)}Key id;`);
+        }
+      }
+      const javaType = jmapping[result[i].data_type.split('(')[0]];
+      if (javaType) {
+        if (javaTypeImport[javaType]) imports.add(javaTypeImport[javaType]);
+        const fieldsForTable = result
+          .filter((row) => row.table_name === currentTable)
+          .map((row) => row.field_name);
+        const commonPrefix = detectMostCommonPrefix(fieldsForTable);
+
+        if (currentTable !== result[i].table_name) {
+          fs.writeFileSync(
+            __dirname + '/../../../../shared/' + currentTable + '.json',
+            JSON.stringify(zmap)
+          );
+          INSTALLED_FILES.push(
+            __dirname + '/../../../../shared/' + currentTable + '.json'
+          );
+          zmap = {};
+
+          createEntity(currentTable, imports, fields);
+          fields = [];
+          currentTable = result[i].table_name;
+
+          fields.push(`@Data`);
+          fields.push(`@EqualsAndHashCode(callSuper=false)`);
+          fields.push(`@Entity`);
+          fields.push(`@Table(name = "${currentTable}")`);
+          fields.push(
+            'public class ' +
+              toPascalCase(currentTable) +
+              ' extends GenericEntity {'
+          );
+          fields.push(' ');
+        }
+
+        if (result[i].is_primary_key === 'YES') {
+          if (isCompositeKey(currentTable, result) === false) {
+            if (result[i].data_type.includes('character')) {
+              fields.push('@Id');
+              fields.push(`@Column(name = "${result[i].field_name}")`);
+              fields.push(`private String id;`);
+              zmap[result[i].field_name] = 'id';
+            } else {
+              fields.push('@Id');
+              if (result[i].sequence_name) {
+                fields.push(`@Column(name = "${result[i].field_name}")`);
+                fields.push(
+                  `@GeneratedValue(generator = "${result[i].table_name}_${result[i].field_name}_seq", strategy = GenerationType.SEQUENCE)`
+                );
+                fields.push(
+                  `@SequenceGenerator(name="${result[i].table_name}_${result[i].field_name}_seq", sequenceName="${result[i].sequence_name}", allocationSize=${result[i].allocation_size})`
+                );
+              } else fields.push(`@Column(name = "${result[i].field_name}")`);
+              fields.push(`private ${jmapping[result[i].data_type]} id;`);
+              zmap[result[i].field_name] = 'id';
+            }
+          }
+        } else {
+          if (result[i].foreign_table_name) {
+            fields.push('@ManyToOne(fetch = FetchType.EAGER, optional = true)');
+            fields.push(
+              `@JoinColumn(name = "${result[i].field_name}", referencedColumnName = "${result[i].foreign_column_name}")`
+            );
+            //fields.push('@JsonProperty');
+            if (result[i].is_required === 'YES') fields.push('@NotNull');
+            if (result[i].foreign_table_name == 'users') {
+              fields.push(
+                `private User ${
+                  toCamelCase(result[i].field_name).split('Id')[0]
+                };`
+              );
+            } else
+              fields.push(
+                `private ${toPascalCase(result[i].foreign_table_name)} ${
+                  toCamelCase(result[i].field_name).split('Id')[0]
+                };`
+              );
+            zmap[result[i].field_name] = toCamelCase(
+              result[i].field_name
+            ).split('Id')[0];
+          } else {
+            fields.push(`@Column(name = "${result[i].field_name}")`);
+            //fields.push('@JsonProperty');
+            if (result[i].is_required === 'YES') fields.push('@NotNull');
+            fields.push(
+              `private ${javaType} ${toCamelCase(
+                removeTablePrefix(result[i].field_name, commonPrefix)
+              )};`
+            );
+            zmap[result[i].field_name] = toCamelCase(
+              removeTablePrefix(result[i].field_name, commonPrefix)
+            );
+          }
+        }
+        fields.push(' ');
+      }
+    }
+    fs.writeFileSync(
+      __dirname + '/../../../../shared/' + currentTable + '.json',
+      JSON.stringify(zmap)
+    );
+    INSTALLED_FILES.push(
+      __dirname + '/../../../../shared/' + currentTable + '.json'
+    );
+    createEntity(currentTable, imports, fields);
+
+    cb();
+  };
+
+  const spinner = ora('Mise à jour enums').start();
+  createEnums(async () => {
+    spinner.succeed('Enums mis à jour');
+    const spinner3 = ora('Mise à jour entities').start();
+    const result = await getTableComposition(schema);
+    if (result.length === 0) {
+      sequelize.close();
+      return spinner3.fail('Aucune table trouvée');
+    }
+    createEntities((o, msg) => {
+      if (o) {
+        sequelize.close();
+        return spinner3.fail(msg);
+      }
+      spinner3.succeed('Entities mis à jour');
+      const spinner2 = ora('Mis à jour interface cliente').start();
+      createClientInterface(() => {
+        fs.writeFileSync(
+          `${__dirname}/../../../../shared/models.cache`,
+          JSON.stringify(INSTALLED_FILES)
+        );
+        spinner2.succeed('Interface cliente mise à jour');
+        fs.writeFileSync(
+          __dirname + '/../../../../watcher/pid',
+          new Date().toISOString()
+        );
+        sequelize.close();
+      });
+    });
+  });
+};