@cerema/cadriciel 1.1.1 → 1.1.3

package/cmd/login.js

@@ -24,7 +24,7 @@ module.exports = function (program) {
       ])
       .then(async (answers) => {
         var client = await S3(answers);
-        client.get('templates', 'template.json', function (e, r) {
+        client.get('cadriciel-templates', 'template.json', function (e, r) {
           if (e) return log.error('Votre login ou mot de passe incorrecte');
           makeAccount(JSON.stringify(answers), function (e) {
             if (e) return log.error('Impossible de créer votre compte.');
@@ -33,6 +33,7 @@ module.exports = function (program) {
         });
       })
       .catch((error) => {
+        console.log(error);
         throw error;
       });
   };

package/cmd/update.js

@@ -7,7 +7,7 @@ module.exports = function (program) {
     console.log('- Mise à jour du cadriciel');
     /** update json */
     const s3 = await S3();
-    s3.get('templates', 'template.json', function (e) {
+    s3.get('cadriciel-templates', 'template.json', function (e) {
       fs.rename(
         os.tmpdir() + '/template.json',
         os.homedir() + '/.cadriciel/template.json',

package/lib/s3.js

@@ -2,13 +2,19 @@ const os = require('os');
 const fs = require('fs');
 const util = require('util');
 const S3_URI = 's3.gra.io.cloud.ovh.net';
+const S3_REGION = 'gra';
 const Minio = require('minio');
 
 const readFile = util.promisify(fs.readFile);
 
 const S3 = async function (current_login) {
   const login = async () => {
+    current_login.endPoint = S3_URI;
+    current_login.region = S3_REGION;
+    if (current_login) return new Minio.Client(current_login);
     const r = await readFile(`${os.homedir}/.cadriciel/account.json`, 'utf-8');
+    r.endPoint = S3_URI;
+    r.region = S3_REGION;
     if (r) return new Minio.Client(JSON.parse(r));
   };
   var client = await login(current_login);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cerema/cadriciel",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "main": "index.js",
   "license": "MIT",
   "npm": ">=8.0.0",

package/aaaa/.cadriciel/.uuid

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

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

@@ -1,337 +0,0 @@
-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');
-    });
-  });
-});