@simtlix/simfinity-js 2.4.2 → 2.4.6

package/git-report.js

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+
+import { execFileSync } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const CHANGE_TYPE_LABELS = {
+  A: 'Added',
+  M: 'Modified',
+  D: 'Deleted',
+  R: 'Renamed',
+  C: 'Copied',
+  T: 'TypeChanged',
+};
+
+const COMMIT_DELIMITER = '---GIT_REPORT_COMMIT---';
+const FIELD_DELIMITER = '---GIT_REPORT_FIELD---';
+
+function printHelp() {
+  const help = `
+Usage: node git-report.js --branch <branch> --author <author> --months <N> [--output <file.csv>]
+
+Generate a CSV report of git commits for a given author on a branch within a time period.
+
+Required arguments:
+  --branch <branch>   Git branch name to analyze
+  --author <author>   Git author name or email to filter by
+  --months <N>        Number of months to look back from today
+
+Optional arguments:
+  --output <file>     Output CSV file path (default: git-report.csv)
+  --help, -h          Show this help message and exit
+
+Output:
+  A CSV file with one row per affected file per commit, containing:
+    commit_hash, author, date, message, change_type, file_path
+
+Examples:
+  node git-report.js --branch master --author "John Doe" --months 3
+  node git-report.js --branch main --author john@example.com --months 6 --output report.csv
+`;
+  console.log(help.trim());
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const opts = {};
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case '--branch':
+        opts.branch = args[++i];
+        break;
+      case '--author':
+        opts.author = args[++i];
+        break;
+      case '--months':
+        opts.months = args[++i];
+        break;
+      case '--output':
+        opts.output = args[++i];
+        break;
+      default:
+        console.error(`Unknown argument: ${args[i]}`);
+        printHelp();
+        process.exit(1);
+    }
+  }
+
+  const missing = [];
+  if (!opts.branch) missing.push('--branch');
+  if (!opts.author) missing.push('--author');
+  if (!opts.months) missing.push('--months');
+
+  if (missing.length > 0) {
+    console.error(`Missing required arguments: ${missing.join(', ')}`);
+    printHelp();
+    process.exit(1);
+  }
+
+  const months = parseInt(opts.months, 10);
+  if (Number.isNaN(months) || months <= 0) {
+    console.error('--months must be a positive integer');
+    process.exit(1);
+  }
+  opts.months = months;
+  opts.output = opts.output || 'git-report.csv';
+
+  return opts;
+}
+
+function validateGitEnvironment() {
+  try {
+    execFileSync('git', ['--version'], { stdio: 'pipe' });
+  } catch {
+    console.error('Error: git is not installed or not found in PATH.');
+    process.exit(1);
+  }
+
+  try {
+    execFileSync('git', ['rev-parse', '--is-inside-work-tree'], { stdio: 'pipe' });
+  } catch {
+    console.error('Error: current directory is not inside a git repository.');
+    process.exit(1);
+  }
+}
+
+function computeSinceDate(months) {
+  const date = new Date();
+  date.setMonth(date.getMonth() - months);
+  return date.toISOString().slice(0, 10);
+}
+
+function escapeCsvField(value) {
+  const str = String(value).replace(/\r?\n/g, ' ');
+  if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+
+function getGitLog(branch, author, sinceDate) {
+  const format = [
+    `${COMMIT_DELIMITER}`,
+    `%h${FIELD_DELIMITER}%an${FIELD_DELIMITER}%ai${FIELD_DELIMITER}%s`,
+  ].join('');
+
+  const args = [
+    'log',
+    `--format=${format}`,
+    '--name-status',
+    `--author=${author}`,
+    `--since=${sinceDate}`,
+    branch,
+  ];
+
+  try {
+    return execFileSync('git', args, { encoding: 'utf-8', maxBuffer: 50 * 1024 * 1024 });
+  } catch (err) {
+    console.error(`Error running git log: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function parseGitLog(rawOutput) {
+  const rows = [];
+  const commits = rawOutput.split(COMMIT_DELIMITER).filter((s) => s.trim());
+
+  for (const block of commits) {
+    const lines = block.trim().split('\n');
+    if (lines.length === 0) continue;
+
+    const headerLine = lines[0];
+    const parts = headerLine.split(FIELD_DELIMITER);
+    if (parts.length < 4) continue;
+
+    const [hash, author, dateRaw, message] = parts;
+    const date = dateRaw.slice(0, 10);
+
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line) continue;
+
+      const match = line.match(/^([AMDRTC])\d*\t(.+)$/);
+      if (!match) continue;
+
+      const statusCode = match[1];
+      const filePath = match[2].includes('\t') ? match[2].split('\t').pop() : match[2];
+      const changeType = CHANGE_TYPE_LABELS[statusCode] || statusCode;
+
+      rows.push({
+        commit_hash: hash,
+        author,
+        date,
+        message,
+        change_type: changeType,
+        file_path: filePath,
+      });
+    }
+  }
+
+  return rows;
+}
+
+function writeCsv(rows, outputPath) {
+  const columns = ['commit_hash', 'author', 'date', 'message', 'change_type', 'file_path'];
+  const header = columns.join(',');
+  const lines = rows.map((row) => columns.map((col) => escapeCsvField(row[col])).join(','));
+
+  const csv = [header, ...lines, ''].join('\n');
+  const absPath = resolve(outputPath);
+  writeFileSync(absPath, csv, 'utf-8');
+  return absPath;
+}
+
+function main() {
+  const opts = parseArgs(process.argv);
+  validateGitEnvironment();
+
+  const sinceDate = computeSinceDate(opts.months);
+  console.error(`Searching commits on branch "${opts.branch}" by "${opts.author}" since ${sinceDate}...`);
+
+  const rawLog = getGitLog(opts.branch, opts.author, sinceDate);
+  const rows = parseGitLog(rawLog);
+
+  const uniqueCommits = new Set(rows.map((r) => r.commit_hash)).size;
+
+  if (rows.length === 0) {
+    console.error('No commits found matching the criteria.');
+    process.exit(0);
+  }
+
+  const absPath = writeCsv(rows, opts.output);
+
+  console.error(`Done. ${uniqueCommits} commit(s), ${rows.length} file change(s).`);
+  console.error(`Report written to: ${absPath}`);
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simtlix/simfinity-js",
-  "version": "2.4.2",
+  "version": "2.4.6",
   "description": "",
   "main": "src/index.js",
   "type": "module",

package/src/auth/index.js

@@ -16,19 +16,19 @@
  * 
  * const permissions = {
  *   Query: {
- *     users: requireAuth(),
- *     adminDashboard: requireRole('ADMIN')
+ *     series: requireAuth(),
+ *     seasons: requireAuth(),
  *   },
  *   Mutation: {
- *     publishPost: requireRole('EDITOR')
+ *     deleteserie: requireRole('admin'),
+ *     deletestar: requireRole('admin'),
  *   },
- *   User: {
+ *   serie: {
  *     '*': requireAuth(),
- *     email: requireRole('ADMIN')
  *   }
  * };
  * 
- * const authPlugin = createAuthPlugin(permissions, { defaultPolicy: 'DENY' });
+ * const authPlugin = createAuthPlugin(permissions, { defaultPolicy: 'ALLOW' });
  * const yoga = createYoga({ schema, plugins: [authPlugin] });
  */
 

package/src/index.js

@@ -416,8 +416,8 @@ const buildInputType = (gqltype) => {
           if (fieldEntry.type.ofType === gqltype) {
             selfReferenceCollections[fieldEntryName] = fieldEntry;
           } else {
-            const listInputTypeForAdd = graphQLListInputType(typesDict, fieldEntry, fieldEntryName, 'A', fieldEntry.extensions?.relation?.connectionField);
-            const listInputTypeForUpdate = graphQLListInputType(typesDictForUpdate, fieldEntry, fieldEntryName, 'U', fieldEntry.extensions?.relation?.connectionField);
+            const listInputTypeForAdd = graphQLListInputType(typesDict, fieldEntry, fieldEntryName, gqltype.name + 'A', fieldEntry.extensions?.relation?.connectionField);
+            const listInputTypeForUpdate = graphQLListInputType(typesDictForUpdate, fieldEntry, fieldEntryName, gqltype.name +'U', fieldEntry.extensions?.relation?.connectionField);
             if (listInputTypeForAdd && listInputTypeForUpdate) {
               fieldArg.type = listInputTypeForAdd;
               fieldArgForUpdate.type = listInputTypeForUpdate;
@@ -680,7 +680,10 @@ const onUpdateSubject = async (Model, gqltype, controller, args, session, linkTo
 
     if (args[fieldEntryName] === null
       && !(fieldEntry.type instanceof GraphQLNonNull)) {
-      materializedModel.modelArgs = { ...materializedModel.modelArgs, $unset: { [fieldEntryName]: '' } };
+      materializedModel.modelArgs = {
+        ...materializedModel.modelArgs,
+        $unset: { ...materializedModel.modelArgs.$unset, [fieldEntryName]: '' },
+      };
     }
   });