@cerema/cadriciel 1.1.0 → 1.1.1

package/aaaa/.cadriciel/.uuid

@@ -0,0 +1 @@
+ELZJq-3IJ

package/aaaa/.cadriciel/bin/db-update.js

@@ -0,0 +1,337 @@
+const fs = require('fs');
+
+const { Sequelize } = require('sequelize');
+const exec = require('child_process').exec;
+const ora = require('ora');
+
+const dir = __dirname + '/../../api';
+const data_dir = fs.readdirSync(dir);
+const commondir = 'main/java/fr/cerema/dsi';
+const commondot = commondir.replace(/\//g, '.').split('main.java.')[1];
+
+const SETUP = fs.readFileSync(`${__dirname}/../.uuid`, 'utf-8');
+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,
+});
+
+const capitalizeFirstLetter = (str) => {
+  if (!str || typeof str !== 'string') {
+    return '';
+  }
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+
+const entities_header = `package ${commondot}.${schema}.entities;`;
+
+const entities_imports = [
+  `import ${commondot}.commons.entities.GenericEntity;`,
+  'import jakarta.persistence.*;',
+  'import com.fasterxml.jackson.annotation.JsonProperty;',
+  'import lombok.*;',
+];
+
+// 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}/../../api/${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}/${capitalizeFirstLetter(data[0][0].enum_name)}.java`;
+  const className = commondot + '.' + schema + '.enums';
+  let package = [
+    `package ${className};`,
+    ` `,
+    `public enum ${capitalizeFirstLetter(data[0][0].enum_name)} {`,
+  ];
+  for (let i = 0; i < data[0].length; i++) {
+    let newfilename = `${dir}/${capitalizeFirstLetter(
+      data[0][i].enum_name
+    )}.java`;
+    if (newfilename !== filename) {
+      package.push('}');
+      fs.writeFileSync(filename, package.join('\n'));
+      filename = newfilename;
+      package = [
+        `package ${className};`,
+        ` `,
+        `public enum ${capitalizeFirstLetter(data[0][i].enum_name)} {`,
+      ];
+    }
+    package.push('  ' + data[0][i].enum_value + ',');
+  }
+  package.push('}');
+  fs.writeFileSync(filename, package.join('\n'));
+  cb();
+};
+
+const createClientInterface = (cb) => {
+  exec(
+    `${__dirname}/../../node_modules/.bin/pg-to-ts generate -c ${uri} -s ${schema} -o ${__dirname}/../../client/app/interfaces/dbschema.ts`,
+    (err, stdout, stderr) => {
+      //console.log(err, stdout, stderr);
+      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 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
+)
+
+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
+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
+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);
+  }
+};
+
+const jmapping = {
+  text: 'String',
+  character: 'String',
+  bigint: 'Long',
+  integer: 'Integer',
+  smallint: 'Short',
+  'double precision': 'Double',
+  real: 'Float',
+  boolean: 'Boolean',
+  bytea: 'Byte[]',
+  timestamp: 'Date',
+  date: 'LocalDate',
+  numeric: 'BigDecimal',
+  decimal: 'BigDecimal',
+};
+
+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 createEntities = async (cb) => {
+  let entities = JSON.parse(JSON.stringify(entities_imports));
+  const createEntity = (tbl, o, fields) => {
+    entities.push(' ');
+    entities.push('@Entity');
+    entities.push('@Table(name = "' + tbl + '")');
+    entities.push('@Getter');
+    entities.push('@Setter');
+    entities.push('@NoArgsConstructor');
+    entities.push('@AllArgsConstructor');
+    entities.push('@EqualsAndHashCode(callSuper = false)');
+    entities.push(' ');
+    fields.splice(1, 0, ...entities);
+
+    entities = JSON.parse(JSON.stringify(entities_imports));
+    let dir = `${__dirname}/../../api/${schema}-transverse`;
+    dir += `/src/${commondir}/${schema}/entities`;
+    let filename = `${dir}/${toPascalCase(tbl)}.java`;
+    const className = commondot + '.' + schema + '.entities';
+    fields.push('@Override');
+    fields.push('public String toString() {');
+    fields.push(generateJavaToString(tbl, o));
+    fields.push('}');
+    fields.push('}');
+    fs.writeFileSync(filename, fields.join('\n'));
+  };
+  const result = await getTableComposition(schema);
+
+  let tbl = result[0].table_name;
+  let fields = [];
+  let o = [];
+  fields.push(entities_header.replace('%', tbl));
+  fields.push(' ');
+  fields.push('public class ' + toPascalCase(tbl) + ' extends GenericEntity {');
+  for (let i = 0; i < result.length; i++) {
+    const javaType = jmapping[result[i].data_type.split(' ')[0]];
+
+    if (javaType == 'Date') entities.push('import java.util.Date;');
+    if (tbl != result[i].table_name) {
+      createEntity(tbl, o, fields);
+      o = [];
+      fields = [];
+      tbl = result[i].table_name;
+      fields.push(entities_header.replace('%', tbl));
+      fields.push(' ');
+      fields.push(
+        'public class ' + toPascalCase(tbl) + ' extends GenericEntity {'
+      );
+    }
+    if (result[i].is_primary_key == 'YES') {
+      fields.push('@Id');
+      if (result[i].data_type == 'integer' || result[i].data_type == 'bigint') {
+        fields.push(
+          '@SequenceGenerator(name = "' +
+            result[i].table_name +
+            '_' +
+            result[i].field_name +
+            '_seq", sequenceName = "' +
+            result[i].table_name +
+            '_' +
+            result[i].field_name +
+            '_seq", allocationSize = 1)'
+        );
+        fields.push(
+          '@GeneratedValue(generator = "' +
+            result[i].table_name +
+            '_' +
+            result[i].field_name +
+            '_seq", strategy = GenerationType.SEQUENCE)'
+        );
+        fields.push('@JsonProperty');
+        fields.push('private Long ' + result[i].field_name + ';');
+        fields.push(' ');
+      }
+    } else {
+      if (result[i].foreign_table_name) {
+        fields.push('@ManyToOne(fetch = FetchType.LAZY, optional = false)');
+        fields.push(
+          '@JoinColumn(name = "' +
+            result[i].field_name +
+            '", referencedColumnName = "' +
+            result[i].foreign_column_name +
+            '")'
+        );
+        fields.push('@JsonProperty');
+        if (result[i].foreign_table_name == 'users')
+          result[i].foreign_table_name = 'user';
+        fields.push(
+          'private ' +
+            toPascalCase(result[i].foreign_table_name) +
+            ' ' +
+            result[i].foreign_table_name +
+            ';'
+        );
+        fields.push(' ');
+      } else {
+        fields.push('@Column(name = "' + result[i].field_name + '")');
+        fields.push('@JsonProperty');
+        fields.push('private ' + javaType + ' ' + result[i].field_name + ';');
+        fields.push(' ');
+      }
+    }
+    if (result[i].foreign_table_name) o.push(result[i].foreign_table_name);
+    else o.push(result[i].field_name);
+  }
+  createEntity(tbl, o, fields);
+  sequelize.close();
+  cb();
+};
+
+const spinner = ora('Updating enums').start();
+createEnums(() => {
+  spinner.succeed('Enums updated');
+  const spinner2 = ora('Updating client interface').start();
+  createClientInterface(() => {
+    spinner2.succeed('Client interface updated');
+    const spinner3 = ora('Updating entities').start();
+    createEntities(() => {
+      spinner3.succeed('Entities updated');
+    });
+  });
+});